API Reference

new DialClient(config: DialClientConfig)

const dial = new DialClient({
  apiKey: 'your-api-key',
  walletAddress: '0x...',
  network: 'mainnet'
});

await dial.authenticate(params: AuthParams): Promise<Session>

await dial.calls.start(params: StartCallParams): Promise<Call>

await dial.calls.answer(callId: string): Promise<void>

await dial.calls.decline(callId: string, options?: DeclineOptions): Promise<void>

await dial.calls.end(callId: string): Promise<void>

await dial.calls.mute(callId: string): Promise<void>

await dial.calls.unmute(callId: string): Promise<void>

await dial.calls.toggleMute(callId: string): Promise<boolean>

await dial.calls.disableVideo(callId: string): Promise<void>

await dial.calls.enableVideo(callId: string): Promise<void>

await dial.calls.getHistory(params?: HistoryParams): Promise<CallRecord[]>

await dial.messages.send(params: SendMessageParams): Promise<Message>

await dial.messages.getConversations(): Promise<Conversation[]>

await dial.messages.getConversation(params: {
  with: string
}): Promise<Conversation>

await dial.messages.getMessages(params: MessageHistoryParams): Promise<Message[]>

await dial.messages.markAsRead(messageId: string): Promise<void>

await dial.messages.addReaction(params: {
  messageId: string;
  emoji: string;
}): Promise<void>

await dial.messages.delete(messageId: string, options?: {
  forEveryone?: boolean;
}): Promise<void>

await dial.voicemail.record(params: RecordParams): Promise<Voicemail>

await dial.voicemail.getAll(params?: {
  limit?: number;
  unreadOnly?: boolean;
}): Promise<Voicemail[]>

await dial.voicemail.get(voicemailId: string): Promise<Voicemail>

await dial.voicemail.markAsRead(voicemailId: string): Promise<void>

await dial.voicemail.delete(voicemailId: string): Promise<void>

await dial.voicemail.transcribe(voicemailId: string): Promise<Transcription>

await dial.conference.create(params: CreateRoomParams): Promise<ConferenceRoom>

await dial.conference.join(params: JoinParams): Promise<void>

await dial.conference.leave(roomId: string): Promise<void>

await dial.conference.muteAudio(roomId: string): Promise<void>

await dial.conference.startScreenShare(roomId: string): Promise<void>

await dial.gatedRooms.create(params: CreateGatedRoomParams): Promise<GatedRoom>

await dial.gatedRooms.checkAccess(params: {
  roomId: string;
  walletAddress: string;
}): Promise<AccessResult>

interface AccessResult {
  allowed: boolean;
  reason?: string;
  requirementsMet?: string[];
  missingRequirements?: string[];
}

await dial.streaming.create(params: CreateStreamParams): Promise<LiveStream>

await dial.streaming.start(params: StartStreamParams): Promise<void>

await dial.streaming.end(streamId: string): Promise<void>

await dial.notifications.requestPermissions(): Promise<boolean>

await dial.notifications.register(): Promise<void>

await dial.notifications.setPreferences(prefs: NotificationPreferences): Promise<void>

interface NotificationPreferences {
  calls?: boolean;
  messages?: boolean;
  voicemails?: boolean;
  conferenceInvites?: boolean;
}

dial.on('call:incoming', (call: Call) => void)
dial.on('call:answered', (call: Call) => void)
dial.on('call:ended', (call: Call) => void)
dial.on('call:declined', (call: Call) => void)
dial.on('call:missed', (call: Call) => void)

dial.on('message:received', (message: Message) => void)
dial.on('message:read', (message: Message) => void)
dial.on('typing:start', (data: { from: string }) => void)
dial.on('typing:stop', (data: { from: string }) => void)

dial.on('voicemail:received', (voicemail: Voicemail) => void)

dial.on('conference:participant:joined', (participant: Participant) => void)
dial.on('conference:participant:left', (participant: Participant) => void)
dial.on('conference:screenshare:started', (data: { participantId: string }) => void)

dial.on('stream:viewer:joined', (data: { viewer: Viewer }) => void)
dial.on('stream:viewer:left', (data: { viewer: Viewer }) => void)
dial.on('stream:viewer:count', (data: { count: number }) => void)
dial.on('stream:chat:message', (data: { message: Message, sender: Sender }) => void)

// Remove specific listener
dial.off('call:incoming', handler);
 
// Remove all listeners for event
dial.off('call:incoming');

interface Call {
  id: string;
  from: string;
  to: string;
  type: 'audio' | 'video';
  status: 'ringing' | 'active' | 'ended' | 'missed' | 'declined';
  direction: 'incoming' | 'outgoing';
  startedAt?: Date;
  endedAt?: Date;
  duration?: number;
}

interface Message {
  id: string;
  from: string;
  to: string;
  content: string;
  type: 'text' | 'image' | 'video' | 'audio';
  media?: MediaInfo;
  timestamp: Date;
  status: 'sending' | 'sent' | 'delivered' | 'read' | 'failed';
  reactions?: Reaction[];
}

interface Voicemail {
  id: string;
  from: string;
  to: string;
  audioUrl: string;
  duration: number;
  timestamp: Date;
  isRead: boolean;
  transcription?: string;
}

interface ConferenceRoom {
  id: string;
  name: string;
  host: string;
  participants: Participant[];
  maxParticipants: number;
  createdAt: Date;
  url: string;
  status: 'waiting' | 'active' | 'ended';
}

interface LiveStream {
  id: string;
  title: string;
  description: string;
  host: string;
  streamKey: string;
  url: string;
  playbackUrl: string;
  status: 'idle' | 'live' | 'ended';
  viewerCount: number;
  startedAt?: Date;
  endedAt?: Date;
}

try {
  const call = await dial.calls.start({
    to: '0x...',
    type: 'audio'
  });
} catch (error) {
  if (error.code === 'INVALID_ADDRESS') {
    console.error('Invalid wallet address');
  } else if (error.code === 'PERMISSION_DENIED') {
    console.error('Microphone permission denied');
  } else {
    console.error('Error starting call:', error.message);
  }
}