@wildix/xbees-conversations-client 1.0.44 → 1.0.45

package/dist-types/models/models_0.d.ts

@@ -1,5 +1,6 @@
 import { ConversationsServiceException as __BaseException } from "./ConversationsServiceException";
 import { ExceptionOptionType as __ExceptionOptionType } from "@smithy/smithy-client";
+import { DocumentType as __DocumentType } from "@smithy/types";
 /**
  * @public
  */
@@ -22,6 +23,649 @@ export declare class ForbiddenException extends __BaseException {
      */
     constructor(opts: __ExceptionOptionType<ForbiddenException, __BaseException>);
 }
+/**
+ * @public
+ */
+export interface CallFlowAttachmentDestination {
+    phone?: string;
+    name?: string;
+    email?: string;
+    userId?: string;
+    userExtension?: string;
+    userDepartment?: string;
+    groupId?: string;
+    groupName?: string;
+}
+/**
+ * @public
+ * @enum
+ */
+export declare const CallFlowAttachmentType: {
+    readonly FAX: "FAX";
+    readonly VOICEMAIL: "VOICEMAIL";
+};
+/**
+ * @public
+ */
+export type CallFlowAttachmentType = typeof CallFlowAttachmentType[keyof typeof CallFlowAttachmentType];
+/**
+ * @public
+ * @enum
+ */
+export declare const CallParticipantRole: {
+    readonly AGENT: "AGENT";
+    readonly CLIENT: "CLIENT";
+};
+/**
+ * @public
+ */
+export type CallParticipantRole = typeof CallParticipantRole[keyof typeof CallParticipantRole];
+/**
+ * @public
+ * @enum
+ */
+export declare const CallParticipantType: {
+    readonly LOCAL: "LOCAL";
+    readonly REMOTE: "REMOTE";
+};
+/**
+ * @public
+ */
+export type CallParticipantType = typeof CallParticipantType[keyof typeof CallParticipantType];
+/**
+ * @public
+ * @enum
+ */
+export declare const CallDevice: {
+    readonly COLLABORATION_ANDROID: "COLLABORATION_ANDROID";
+    readonly COLLABORATION_IOS: "COLLABORATION_IOS";
+    readonly COLLABORATION_WEB: "COLLABORATION_WEB";
+    readonly UNKNOWN: "UNKNOWN";
+    readonly WILDIX_DEVICE: "WILDIX_DEVICE";
+    readonly WILDIX_PHONE: "WILDIX_PHONE";
+    readonly XBEES_ANDROID: "XBEES_ANDROID";
+    readonly XBEES_IOS: "XBEES_IOS";
+    readonly XBEES_WEB: "XBEES_WEB";
+};
+/**
+ * @public
+ */
+export type CallDevice = typeof CallDevice[keyof typeof CallDevice];
+/**
+ * @public
+ */
+export interface CallParticipant {
+    type: CallParticipantType;
+    phone?: string;
+    name?: string;
+    company?: string;
+    email?: string;
+    userId?: string;
+    userExtension?: string;
+    userDepartment?: string;
+    groupId?: string;
+    groupName?: string;
+    userAgent?: string;
+    userDevice?: CallDevice;
+    role: CallParticipantRole;
+    license?: string;
+}
+/**
+ * @public
+ * @enum
+ */
+export declare const ConversationStatus: {
+    readonly COMPLETED: "COMPLETED";
+    readonly MISSED: "MISSED";
+};
+/**
+ * @public
+ */
+export type ConversationStatus = typeof ConversationStatus[keyof typeof ConversationStatus];
+/**
+ * @public
+ * @enum
+ */
+export declare const CallDirection: {
+    readonly INBOUND: "INBOUND";
+    readonly INTERNAL: "INTERNAL";
+    readonly OUTBOUND: "OUTBOUND";
+    readonly UNDEFINED: "UNDEFINED";
+};
+/**
+ * @public
+ */
+export type CallDirection = typeof CallDirection[keyof typeof CallDirection];
+/**
+ * @public
+ * @enum
+ */
+export declare const License: {
+    readonly XBEES: "x-bees";
+};
+/**
+ * @public
+ */
+export type License = typeof License[keyof typeof License];
+/**
+ * @public
+ * @enum
+ */
+export declare const CallRecordOwner: {
+    readonly CALLEE: "callee";
+    readonly CALLER: "caller";
+    readonly SYSTEM: "system";
+};
+/**
+ * @public
+ */
+export type CallRecordOwner = typeof CallRecordOwner[keyof typeof CallRecordOwner];
+/**
+ * @public
+ * @enum
+ */
+export declare const CallRecordPauseReason: {
+    readonly HOLD: "hold";
+    readonly PAUSE: "pause";
+};
+/**
+ * @public
+ */
+export type CallRecordPauseReason = typeof CallRecordPauseReason[keyof typeof CallRecordPauseReason];
+/**
+ * @public
+ */
+export interface CallRecordPause {
+    start?: number;
+    end?: number;
+    reason?: CallRecordPauseReason;
+}
+/**
+ * @public
+ */
+export interface RecordingsData {
+    fileName: string;
+    start: number;
+    end: number;
+    owner: CallRecordOwner;
+    url: string;
+    pauses: (CallRecordPause)[];
+}
+/**
+ * @public
+ * @enum
+ */
+export declare const CallFlowTranscriptionStatus: {
+    readonly AVAILABLE: "AVAILABLE";
+    readonly UNAVAILABLE: "UNAVAILABLE";
+};
+/**
+ * @public
+ */
+export type CallFlowTranscriptionStatus = typeof CallFlowTranscriptionStatus[keyof typeof CallFlowTranscriptionStatus];
+/**
+ * @public
+ * @enum
+ */
+export declare const CallTranscriptionSpeaker: {
+    readonly CALLEE: "callee";
+    readonly CALLER: "caller";
+};
+/**
+ * @public
+ */
+export type CallTranscriptionSpeaker = typeof CallTranscriptionSpeaker[keyof typeof CallTranscriptionSpeaker];
+/**
+ * @public
+ */
+export interface CallTranscriptionChunk {
+    id: string;
+    time: number;
+    speaker: CallTranscriptionSpeaker;
+    text: string;
+    language?: string;
+    isFinal: boolean;
+    start: number;
+    end: number;
+    sentiment: string;
+}
+/**
+ * @public
+ * @enum
+ */
+export declare const ConferenceDirection: {
+    readonly INBOUND: "INBOUND";
+    readonly INTERNAL: "INTERNAL";
+    readonly OUTBOUND: "OUTBOUND";
+};
+/**
+ * @public
+ */
+export type ConferenceDirection = typeof ConferenceDirection[keyof typeof ConferenceDirection];
+/**
+ * @public
+ * @enum
+ */
+export declare const PbxLicenseType: {
+    readonly BASIC: "basic";
+    readonly BUSINESS: "business";
+    readonly ESSENTIAL: "essential";
+    readonly PREMIUM: "premium";
+    readonly WIZYCONF: "wizyconf";
+};
+/**
+ * @public
+ */
+export type PbxLicenseType = typeof PbxLicenseType[keyof typeof PbxLicenseType];
+/**
+ * @public
+ * @enum
+ */
+export declare const ConferenceParticipantRole: {
+    readonly AGENT: "AGENT";
+    readonly CLIENT: "CLIENT";
+};
+/**
+ * @public
+ */
+export type ConferenceParticipantRole = typeof ConferenceParticipantRole[keyof typeof ConferenceParticipantRole];
+/**
+ * @public
+ * @enum
+ */
+export declare const ConferenceParticipantType: {
+    readonly EXTERNAL: "EXTERNAL";
+    readonly EXTERNAL_DIAL_IN: "EXTERNAL_DIAL_IN";
+    readonly PBX: "PBX";
+    readonly PBX_SIP: "PBX_SIP";
+    readonly XBS: "XBS";
+};
+/**
+ * @public
+ */
+export type ConferenceParticipantType = typeof ConferenceParticipantType[keyof typeof ConferenceParticipantType];
+/**
+ * @public
+ */
+export interface ConferenceParticipant {
+    type: ConferenceParticipantType;
+    role?: ConferenceParticipantRole;
+    /**
+     * A unique identifier to avoid duplicates if user re-connect from different devices.
+     * @public
+     */
+    jid?: string;
+    name?: string;
+    email?: string;
+    phone?: string;
+    department?: string;
+    company?: string;
+    pbxSerial?: string;
+    pbxExtension?: string;
+    pbxGroupId?: string;
+    xbsId?: string;
+    license?: PbxLicenseType;
+}
+/**
+ * @public
+ */
+export interface ConferenceAnalyticsRecordParticipant {
+    jid: string;
+    info: ConferenceParticipant;
+    totalDuration: number;
+    totalSpeakDuration: number;
+    joinTime: number;
+}
+/**
+ * @public
+ */
+export interface ConferenceRecording {
+    url: string;
+    start: number;
+    end: number;
+}
+/**
+ * @public
+ * @enum
+ */
+export declare const ConferenceTranscriptionStatus: {
+    readonly AVAILABLE: "AVAILABLE";
+    readonly UNAVAILABLE: "UNAVAILABLE";
+};
+/**
+ * @public
+ */
+export type ConferenceTranscriptionStatus = typeof ConferenceTranscriptionStatus[keyof typeof ConferenceTranscriptionStatus];
+/**
+ * @public
+ */
+export interface ConferenceTranscriptionChunk {
+    id: string;
+    time: number;
+    jid: string;
+    text: string;
+    language?: string;
+    isFinal: boolean;
+    start: number;
+    end: number;
+    sentiment: string;
+}
+/**
+ * @public
+ */
+export interface CallTranscription {
+    flowIndex: number;
+    flowStartTime: number;
+    callStartTime: number;
+    chunks: Record<string, CallTranscriptionChunk>;
+}
+/**
+ * @public
+ * @enum
+ */
+export declare const LiveEventType: {
+    readonly CALL: "call";
+    readonly CALL_COMPLETE: "call_complete";
+    readonly CALL_INTERRUPTED: "call_interrupted";
+    readonly CALL_TRANSCRIPTION: "call_transcription";
+    readonly CHAT: "chat";
+    readonly CHAT_COMPLETE: "chat_complete";
+    readonly CHAT_COST: "call_cost";
+    readonly CHAT_INTERRUPTED: "chat_interrupted";
+    readonly CHAT_MISSED: "chat_missed";
+    readonly CONFERENCE: "conference";
+    readonly CONFERENCE_COMPLETE: "conference_complete";
+    readonly CONFERENCE_INTERRUPTED: "conference_interrupted";
+    readonly CONFERENCE_JOIN: "conference_join";
+    readonly CONFERENCE_LEAVE: "conference_leave";
+    readonly CONFERENCE_TRANSCRIPTION: "conference_transcription";
+};
+/**
+ * @public
+ */
+export type LiveEventType = typeof LiveEventType[keyof typeof LiveEventType];
+/**
+ * @public
+ */
+export interface CallAnalyticsCostRecordEvent {
+    id: string;
+    pbx: string;
+    time: number;
+    company: string;
+    licenses: (License)[];
+    transcriptions: (CallTranscription)[];
+    type: LiveEventType;
+    flowIndex: number;
+    cost: number;
+}
+/**
+ * @public
+ */
+export interface CallAnalyticsLiveCompleteEvent {
+    id: string;
+    pbx: string;
+    time: number;
+    company: string;
+    licenses: (License)[];
+    event: LiveEventType;
+    flows: number;
+}
+/**
+ * @public
+ */
+export interface CallAnalyticsLiveInterruptedEvent {
+    id: string;
+    pbx: string;
+    time: number;
+    company: string;
+    licenses: (License)[];
+    event: LiveEventType;
+    flows: number;
+}
+/**
+ * @public
+ * @enum
+ */
+export declare const CallAnalyticsLiveProgressEventTrigger: {
+    readonly AGENTS_CANCEL: "call.agents_cancel";
+    readonly AGENTS_START: "call.agents_start";
+    readonly ATTACHMENT: "call.attachment";
+    readonly RECORD_START: "call.record_start";
+    readonly RECORD_STOP: "call.record_stop";
+    readonly SPLIT: "call.split";
+    readonly START: "call.start";
+    readonly TRANSCRIPTION: "call.transcription";
+    readonly UPDATE: "call.update";
+};
+/**
+ * @public
+ */
+export type CallAnalyticsLiveProgressEventTrigger = typeof CallAnalyticsLiveProgressEventTrigger[keyof typeof CallAnalyticsLiveProgressEventTrigger];
+/**
+ * @public
+ * @enum
+ */
+export declare const CallFlowStatus: {
+    readonly CONNECTING: "CONNECTING";
+    readonly HOLD: "HOLD";
+    readonly TALKING: "TALKING";
+};
+/**
+ * @public
+ */
+export type CallFlowStatus = typeof CallFlowStatus[keyof typeof CallFlowStatus];
+/**
+ * @public
+ */
+export interface CallAnalyticsLiveProgressEventFlow {
+    flowIndex: number;
+    startTime: number;
+    endTime: number;
+    connectTime?: number;
+    talkTime?: number;
+    waitTime?: number;
+    duration: number;
+    caller?: CallParticipant;
+    callee?: CallParticipant;
+    service?: string;
+    serviceNumber?: string;
+    destination?: string;
+    direction?: CallDirection;
+    trunkName?: string;
+    trunkDirection?: string;
+    queueName?: string;
+    queueId?: string;
+    tags?: (string)[];
+    flags?: (string)[];
+    callerMos?: string;
+    calleeMos?: string;
+    xhoppersConfId?: string;
+    recordings?: (string)[];
+    recordingsData?: (RecordingsData)[];
+    mergeWith?: string;
+    splitReason?: string;
+    splitTransferType?: string;
+    remotePhone?: string;
+    remotePhoneCountryCode?: number;
+    remotePhoneCountryCodeStr?: string;
+    remotePhoneLocation?: string;
+    callStatus?: ConversationStatus;
+    transcriptionStatus?: CallFlowTranscriptionStatus;
+    transcriptionLanguage?: string;
+    attachment?: string;
+    attachmentType?: CallFlowAttachmentType;
+    attachmentDestinations?: (CallFlowAttachmentDestination)[];
+    status: CallFlowStatus;
+    /**
+     * Time of the last status change in yyyy-MM-dd'T'HH:mm:ss.SSS'Z' format.
+     * @public
+     */
+    statusChangeDate: string;
+}
+/**
+ * @public
+ */
+export interface CallAnalyticsLiveProgressEvent {
+    id: string;
+    pbx: string;
+    time: number;
+    company: string;
+    licenses: (License)[];
+    event: LiveEventType;
+    /**
+     * An original event that triggers current one.
+     * @public
+     */
+    eventTrigger: CallAnalyticsLiveProgressEventTrigger;
+    start: string;
+    flows: (CallAnalyticsLiveProgressEventFlow)[];
+}
+/**
+ * @public
+ */
+export interface CallAnalyticsLiveTranscriptionEvent {
+    id: string;
+    pbx: string;
+    time: number;
+    company: string;
+    licenses: (License)[];
+    event: LiveEventType;
+    flowIndex: number;
+    flowStartTime: number;
+    callStartTime: number;
+    chunk: CallTranscriptionChunk;
+    participant?: CallParticipant;
+}
+/**
+ * @public
+ * @enum
+ */
+export declare const CallEndBy: {
+    readonly CALLEE: "CALLEE";
+    readonly CALLER: "CALLER";
+};
+/**
+ * @public
+ */
+export type CallEndBy = typeof CallEndBy[keyof typeof CallEndBy];
+/**
+ * @public
+ */
+export interface CallAnalyticsRecordEventFlow {
+    flowIndex: number;
+    startTime: number;
+    endTime: number;
+    connectTime?: number;
+    talkTime?: number;
+    waitTime?: number;
+    duration: number;
+    caller?: CallParticipant;
+    callee?: CallParticipant;
+    service?: string;
+    serviceNumber?: string;
+    destination?: string;
+    direction?: CallDirection;
+    trunkName?: string;
+    trunkDirection?: string;
+    queueName?: string;
+    queueId?: string;
+    tags?: (string)[];
+    flags?: (string)[];
+    callerMos?: string;
+    calleeMos?: string;
+    xhoppersConfId?: string;
+    recordings?: (string)[];
+    recordingsData?: (RecordingsData)[];
+    mergeWith?: string;
+    splitReason?: string;
+    splitTransferType?: string;
+    remotePhone?: string;
+    remotePhoneCountryCode?: number;
+    remotePhoneCountryCodeStr?: string;
+    remotePhoneLocation?: string;
+    callStatus?: ConversationStatus;
+    transcriptionStatus?: CallFlowTranscriptionStatus;
+    transcriptionLanguage?: string;
+    attachment?: string;
+    attachmentType?: CallFlowAttachmentType;
+    attachmentDestinations?: (CallFlowAttachmentDestination)[];
+}
+/**
+ * @public
+ */
+export interface CallAnalyticsRecordEvent {
+    id: string;
+    pbx: string;
+    time: number;
+    company: string;
+    licenses: (License)[];
+    flows: (CallAnalyticsRecordEventFlow)[];
+    endCause?: string;
+    endCauseStr?: string;
+    endBy: CallEndBy;
+    totalConnectTime: number;
+    totalTalkTime: number;
+    totalWaitTime: number;
+    type: LiveEventType;
+    complete: boolean;
+}
+/**
+ * @public
+ */
+export interface CallAnalyticsTranscriptionRecordEvent {
+    id: string;
+    pbx: string;
+    time: number;
+    company: string;
+    licenses: (License)[];
+    transcriptions: (CallTranscription)[];
+    type: LiveEventType;
+    complete: boolean;
+}
+/**
+ * @public
+ * @enum
+ */
+export declare const CallEventType: {
+    readonly COST_RECORD_EVENT: "CallAnalyticsCostRecordEvent";
+    readonly LIVE_COMPLETE_EVENT: "CallAnalyticsLiveCompleteEvent";
+    readonly LIVE_INTERRUPTED_EVENT: "CallAnalyticsLiveInterruptedEvent";
+    readonly LIVE_PROGRESS_EVENT: "CallAnalyticsLiveProgressEvent";
+    readonly LIVE_TRANSCRIPTION_EVENT: "CallAnalyticsLiveTranscriptionEvent";
+    readonly RECORD_EVENT: "CallAnalyticsRecordEvent";
+    readonly TRANSCRIPTION_RECORD_EVENT: "CallAnalyticsTranscriptionRecordEvent";
+};
+/**
+ * @public
+ */
+export type CallEventType = typeof CallEventType[keyof typeof CallEventType];
+/**
+ * @public
+ */
+export interface ChatAnalyticsLiveCompleteEvent {
+    id: string;
+    time: number;
+    company: string;
+    event: LiveEventType;
+}
+/**
+ * @public
+ */
+export interface ChatAnalyticsLiveInterruptedEvent {
+    id: string;
+    time: number;
+    company: string;
+    event: LiveEventType;
+}
+/**
+ * @public
+ */
+export interface ChatAnalyticsLiveMissedEvent {
+    id: string;
+    time: number;
+    company: string;
+    event: LiveEventType;
+}
 /**
  * @public
  */
@@ -29,32 +673,1001 @@ export interface User {
     id: string;
     name?: string;
     email?: string;
-    phone?: string;
-    picture?: string;
-    locale?: string;
-    timeZone?: string;
+    phone?: string;
+    picture?: string;
+    locale?: string;
+    timeZone?: string;
+    company?: string;
+    bot?: boolean;
+    pbxDomain?: string;
+    pbxPort?: string;
+    pbxExtension?: string;
+    pbxSerial?: string;
+    pbxUserId?: string;
+    createdAt?: string;
+    updatedAt?: string;
+}
+/**
+ * @public
+ * @enum
+ */
+export declare const ChannelType: {
+    readonly DIRECT: "direct";
+    readonly GROUP: "group";
+};
+/**
+ * @public
+ */
+export type ChannelType = typeof ChannelType[keyof typeof ChannelType];
+/**
+ * @public
+ * @enum
+ */
+export declare const ChatDirection: {
+    readonly INBOUND: "INBOUND";
+    readonly INTERNAL: "INTERNAL";
+    readonly OUTBOUND: "OUTBOUND";
+};
+/**
+ * @public
+ */
+export type ChatDirection = typeof ChatDirection[keyof typeof ChatDirection];
+/**
+ * @public
+ * @enum
+ */
+export declare const ChatParticipantRole: {
+    readonly AGENT: "AGENT";
+    readonly CLIENT: "CLIENT";
+};
+/**
+ * @public
+ */
+export type ChatParticipantRole = typeof ChatParticipantRole[keyof typeof ChatParticipantRole];
+/**
+ * @public
+ * @enum
+ */
+export declare const ChatParticipantType: {
+    readonly LOCAL: "LOCAL";
+    readonly REMOTE: "REMOTE";
+};
+/**
+ * @public
+ */
+export type ChatParticipantType = typeof ChatParticipantType[keyof typeof ChatParticipantType];
+/**
+ * @public
+ */
+export interface ChatParticipant {
+    id: string;
+    name?: string;
+    email?: string;
+    phone?: string;
+    picture?: string;
+    locale?: string;
+    timeZone?: string;
+    company?: string;
+    bot?: boolean;
+    pbxDomain?: string;
+    pbxPort?: string;
+    pbxExtension?: string;
+    pbxSerial?: string;
+    pbxUserId?: string;
+    createdAt?: string;
+    updatedAt?: string;
+    type: ChatParticipantType;
+    role: ChatParticipantRole;
+}
+/**
+ * @public
+ * @enum
+ */
+export declare const ChatStatus: {
+    readonly COMPLETED: "COMPLETED";
+    readonly MISSED: "MISSED";
+    readonly WAITFIRSTREPLY: "WAITFIRSTREPLY";
+    readonly WAITREPLYFROMAGENT: "WAITREPLYFROMAGENT";
+    readonly WAITREPLYFROMGUEST: "WAITREPLYFROMGUEST";
+};
+/**
+ * @public
+ */
+export type ChatStatus = typeof ChatStatus[keyof typeof ChatStatus];
+/**
+ * @public
+ * @enum
+ */
+export declare const ChatTag: {
+    readonly SMS: "sms";
+    readonly TELEPHONY: "telephony";
+};
+/**
+ * @public
+ */
+export type ChatTag = typeof ChatTag[keyof typeof ChatTag];
+/**
+ * @public
+ */
+export interface ChatAnalyticsLiveProgressEvent {
+    id: string;
+    time: number;
+    company: string;
+    event: LiveEventType;
+    start: string;
+    channelId: string;
+    channelType: ChannelType;
+    subject: string;
+    service?: string;
+    serviceTitle?: string;
+    participants: (ChatParticipant)[];
+    agents: (User)[];
+    agentsCount: number;
+    customers: (User)[];
+    customersCount: number;
+    tags?: (ChatTag)[];
+    direction: ChatDirection;
+    status: ChatStatus;
+}
+/**
+ * @public
+ */
+export interface ChatAnalyticsManagerMissedEvent {
+    id: string;
+    time: number;
+    company: string;
+    event: string;
+}
+/**
+ * @public
+ */
+export interface ChatAnalyticsRecordParticipant {
+    id: string;
+    info: ChatParticipant;
+}
+/**
+ * @public
+ */
+export interface ChatAnalyticsRecordEvent {
+    id: string;
+    time: number;
+    company: string;
+    type: string;
+    duration?: number;
+    subject?: string;
+    direction?: ChatDirection;
+    service?: string;
+    serviceTitle?: string;
+    tags?: (ChatTag)[];
+    status?: ChatStatus;
+    participants?: (ChatAnalyticsRecordParticipant)[];
+}
+/**
+ * @public
+ * @enum
+ */
+export declare const ChatEventType: {
+    readonly LIVE_COMPLETE_EVENT: "ChatAnalyticsLiveCompleteEvent";
+    readonly LIVE_INTERRUPTED_EVENT: "ChatAnalyticsLiveInterruptedEvent";
+    readonly LIVE_MISSED_EVENT: "ChatAnalyticsLiveMissedEvent";
+    readonly LIVE_PROGRESS_EVENT: "ChatAnalyticsLiveProgressEvent";
+    readonly MANAGER_MISSED_EVENT: "ChatAnalyticsManagerMissedEvent";
+    readonly RECORD_EVENT: "ChatAnalyticsRecordEvent";
+};
+/**
+ * @public
+ */
+export type ChatEventType = typeof ChatEventType[keyof typeof ChatEventType];
+/**
+ * @public
+ */
+export interface ConferenceAnalyticsLiveCompleteEvent {
+    id: string;
+    time: number;
+    company: string;
+    event: LiveEventType;
+}
+/**
+ * @public
+ */
+export interface ConferenceAnalyticsLiveInterruptedEvent {
+    id: string;
+    time: number;
+    company: string;
+    event: LiveEventType;
+}
+/**
+ * @public
+ */
+export interface ConferenceAnalyticsLiveJoinEvent {
+    id: string;
+    time: number;
+    company: string;
+    event: LiveEventType;
+    participant: ConferenceParticipant;
+}
+/**
+ * @public
+ */
+export interface ConferenceAnalyticsLiveLeaveEvent {
+    id: string;
+    time: number;
+    company: string;
+    event: LiveEventType;
+    participant: ConferenceParticipant;
+}
+/**
+ * @public
+ */
+export interface ConferenceAnalyticsLiveProgressEvent {
+    id: string;
+    time: number;
+    company: string;
+    event: LiveEventType;
+    start: string;
+    subject: string;
+    participants: (ConferenceParticipant)[];
+    transcriptionStatus: ConferenceTranscriptionStatus;
+    transcriptionLanguage?: string;
+}
+/**
+ * @public
+ */
+export interface ConferenceAnalyticsLiveTranscriptionEvent {
+    id: string;
+    time: number;
+    company: string;
+    event: LiveEventType;
+    conferenceStartTime: number;
+    transcriptionStartTime: number;
+    chunk: ConferenceTranscriptionChunk;
+    participant?: ConferenceParticipant;
+}
+/**
+ * @public
+ */
+export interface ConferenceAnalyticsRecordEvent {
+    id: string;
+    time: number;
+    company: string;
+    pbx?: string;
+    startTime: number;
+    endTime: number;
+    duration: number;
+    waitTime?: number;
+    subject?: string;
+    direction: ConferenceDirection;
+    service?: string;
+    status?: ConversationStatus;
+    participants: (ConferenceAnalyticsRecordParticipant)[];
+    recordings?: (ConferenceRecording)[];
+    transcriptionStatus: ConferenceTranscriptionStatus;
+    transcriptionLanguage?: string;
+    type: LiveEventType;
+    transcriptions?: string;
+}
+/**
+ * @public
+ */
+export interface ConferenceTranscription {
+    start: number;
+    end: number;
+    chunks: Record<string, ConferenceTranscriptionChunk>;
+}
+/**
+ * @public
+ */
+export interface ConferenceAnalyticsTranscriptionRecordEvent {
+    id: string;
+    time: number;
+    company: string;
+    transcriptions: (ConferenceTranscription)[];
+    type: LiveEventType;
+    subject?: string;
+    participants?: Record<string, ConferenceParticipant>;
+}
+/**
+ * @public
+ * @enum
+ */
+export declare const ConferenceEventType: {
+    readonly LIVE_COMPLETE_EVENT: "ConferenceAnalyticsLiveCompleteEvent";
+    readonly LIVE_INTERRUPTED_EVENT: "ConferenceAnalyticsLiveInterruptedEvent";
+    readonly LIVE_JOIN_EVENT: "ConferenceAnalyticsLiveJoinEvent";
+    readonly LIVE_LEAVE_EVENT: "ConferenceAnalyticsLiveLeaveEvent";
+    readonly LIVE_PROGRESS_EVENT: "ConferenceAnalyticsLiveProgressEvent";
+    readonly LIVE_TRANSCRIPTION_EVENT: "ConferenceAnalyticsLiveTranscriptionEvent";
+    readonly RECORD_EVENT: "ConferenceAnalyticsRecordEvent";
+    readonly TRANSCRIPTION_RECORD_EVENT: "ConferenceAnalyticsTranscriptionRecordEvent";
+};
+/**
+ * @public
+ */
+export type ConferenceEventType = typeof ConferenceEventType[keyof typeof ConferenceEventType];
+/**
+ * @public
+ */
+export interface SmsInboundConsumeEventData {
+    /**
+     * A unique ID of the SMS message (example fb0ee129-f98f-4d7f-af1e-32b657aa3a56)
+     * @public
+     */
+    id: string;
+    from: string;
+    to: string;
+    message: string;
+}
+/**
+ * @public
+ * @enum
+ */
+export declare const SmsConsumeEventType: {
+    readonly SMS_INBOUND: "SMS.INBOUND";
+    readonly SMS_STATUS: "SMS.STATUS";
+};
+/**
+ * @public
+ */
+export type SmsConsumeEventType = typeof SmsConsumeEventType[keyof typeof SmsConsumeEventType];
+/**
+ * @public
+ * @enum
+ */
+export declare const SmsChannelType: {
+    readonly ONE_WAY: "1-way-sms";
+    readonly TWO_WAY: "2-way-sms";
+};
+/**
+ * @public
+ */
+export type SmsChannelType = typeof SmsChannelType[keyof typeof SmsChannelType];
+/**
+ * @public
+ * @enum
+ */
+export declare const SmsStatus: {
+    readonly DELIVERED: "delivered";
+    readonly ERROR: "error";
+    readonly SENT: "sent";
+    readonly TRYING: "trying";
+};
+/**
+ * @public
+ */
+export type SmsStatus = typeof SmsStatus[keyof typeof SmsStatus];
+/**
+ * @public
+ */
+export interface SmsStatusConsumeEventData {
+    id: string;
+    from: string;
+    to: string;
+    status: SmsStatus;
+    channel: SmsChannelType;
+    parts: number;
+}
+/**
+ * @public
+ */
+export interface SmsInboundEvent {
+    pbx: string;
+    company: string;
+    time: number;
+    type: SmsConsumeEventType;
+    data: SmsInboundConsumeEventData;
+}
+/**
+ * @public
+ */
+export interface SmsStatusEvent {
+    pbx: string;
+    company: string;
+    time: number;
+    type: SmsConsumeEventType;
+    data: SmsStatusConsumeEventData;
+}
+/**
+ * @public
+ */
+export interface DescribeEventInput {
+    SmsInboundEvent?: SmsInboundEvent;
+    SmsStatusEvent?: SmsStatusEvent;
+}
+/**
+ * @public
+ * @enum
+ */
+export declare const PresenceAnalyticsEventType: {
+    readonly PRESENCE: "PRESENCE";
+    readonly PRESENCE_TELEPHONY: "PRESENCE_TELEPHONY";
+};
+/**
+ * @public
+ */
+export type PresenceAnalyticsEventType = typeof PresenceAnalyticsEventType[keyof typeof PresenceAnalyticsEventType];
+/**
+ * @public
+ */
+export interface PresenceAnalyticsConferenceEvent {
+    id?: string;
+    ext?: string;
+    type?: PresenceAnalyticsEventType;
+    time?: number;
+    pbx?: string;
+    company?: string;
+    email?: string;
+    status?: string;
+    sourceId?: string;
+    isJoined?: boolean;
+    isLeaved?: boolean;
+    participant?: ConferenceParticipant;
+}
+/**
+ * @public
+ */
+export interface PresenceAnalyticsStatusEvent {
+    id?: string;
+    ext?: string;
+    type?: PresenceAnalyticsEventType;
+    time?: number;
+    pbx?: string;
+    company?: string;
+    email?: string;
+    status?: string;
+    sourceId?: string;
+    locationAddress?: string;
+    locationLat?: string;
+    locationLng?: string;
+    message?: string;
+    until?: string;
+}
+/**
+ * @public
+ */
+export interface PresenceAnalyticsTelephonyEvent {
+    id?: string;
+    ext?: string;
+    type?: PresenceAnalyticsEventType;
+    time?: number;
+    pbx?: string;
+    company?: string;
+    email?: string;
+    status?: string;
+    sourceId?: string;
+}
+/**
+ * @public
+ * @enum
+ */
+export declare const PresenceEventType: {
+    readonly CONFERENCE_EVENT: "PresenceAnalyticsConferenceEvent";
+    readonly STATUS_EVENT: "PresenceAnalyticsStatusEvent";
+    readonly TELEPHONY_EVENT: "PresenceAnalyticsTelephonyEvent";
+};
+/**
+ * @public
+ */
+export type PresenceEventType = typeof PresenceEventType[keyof typeof PresenceEventType];
+/**
+ * @public
+ * @enum
+ */
+export declare const WebhookEventType: {
+    readonly CALL_COMPLETED: "call:completed";
+    readonly CALL_LIVE_COMPLETED: "call:live:completed";
+    readonly CALL_LIVE_INTERRUPTED: "call:live:interrupted";
+    readonly CALL_LIVE_PROGRESS: "call:live:progress";
+    readonly CALL_LIVE_TRANSCRIPTION: "call:live:transcription";
+    readonly CHAT_COMPLETED: "chat:completed";
+    readonly CHAT_LIVE_COMPLETED: "chat:live:completed";
+    readonly CHAT_LIVE_INTERRUPTED: "chat:live:interrupted";
+    readonly CHAT_LIVE_PROGRESS: "chat:live:progress";
+    readonly CHAT_MANAGER_MISSED: "chat:manager:missed";
+    readonly CONFERENCE_COMPLETED: "conference:completed";
+    readonly CONFERENCE_LIVE_COMPLETED: "conference:live:completed";
+    readonly CONFERENCE_LIVE_INTERRUPTED: "conference:live:interrupted";
+    readonly CONFERENCE_LIVE_JOIN: "conference:live:join";
+    readonly CONFERENCE_LIVE_LEAVE: "conference:live:leave";
+    readonly CONFERENCE_LIVE_PROGRESS: "conference:live:progress";
+    readonly CONFERENCE_LIVE_TRANSCRIPTION: "conference:live:transcription";
+    readonly OLD_CALL_END: "call:end";
+    readonly OLD_CALL_START: "call:start";
+    readonly OLD_CALL_UPDATE: "call:update";
+    readonly PRESENCE_CONFERENCE: "presence:conference";
+    readonly PRESENCE_TELEPHONY: "presence:telephony";
+    readonly PRESENCE_USER: "presence:user";
+};
+/**
+ * @public
+ */
+export type WebhookEventType = typeof WebhookEventType[keyof typeof WebhookEventType];
+/**
+ * @public
+ */
+export interface WebhookCallCompletedEvent {
+    id: string;
+    pbx?: string;
+    company?: string;
+    type: WebhookEventType;
+    time: number;
+    integrationId: string;
+    data: CallAnalyticsRecordEvent;
+}
+/**
+ * @public
+ */
+export interface WebhookCallLiveCompletedEvent {
+    id: string;
+    pbx?: string;
+    company?: string;
+    type: WebhookEventType;
+    time: number;
+    integrationId: string;
+    data: CallAnalyticsLiveCompleteEvent;
+}
+/**
+ * @public
+ */
+export interface WebhookCallLiveInterruptedEvent {
+    id: string;
+    pbx?: string;
+    company?: string;
+    type: WebhookEventType;
+    time: number;
+    integrationId: string;
+    data: CallAnalyticsLiveInterruptedEvent;
+}
+/**
+ * @public
+ */
+export interface WebhookCallLiveProgressEvent {
+    id: string;
+    pbx?: string;
+    company?: string;
+    type: WebhookEventType;
+    time: number;
+    integrationId: string;
+    data: CallAnalyticsLiveProgressEvent;
+}
+/**
+ * @public
+ */
+export interface WebhookCallLiveTranscriptionEvent {
+    id: string;
+    pbx?: string;
+    company?: string;
+    type: WebhookEventType;
+    time: number;
+    integrationId: string;
+    data: CallAnalyticsLiveTranscriptionEvent;
+}
+/**
+ * @public
+ */
+export interface WebhookChatCompletedEvent {
+    id: string;
+    pbx?: string;
+    company?: string;
+    type: WebhookEventType;
+    time: number;
+    integrationId: string;
+    data: ChatAnalyticsRecordEvent;
+}
+/**
+ * @public
+ */
+export interface WebhookChatLiveCompletedEvent {
+    id: string;
+    pbx?: string;
+    company?: string;
+    type: WebhookEventType;
+    time: number;
+    integrationId: string;
+    data: ChatAnalyticsLiveCompleteEvent;
+}
+/**
+ * @public
+ */
+export interface WebhookChatLiveInterruptedEvent {
+    id: string;
+    pbx?: string;
+    company?: string;
+    type: WebhookEventType;
+    time: number;
+    integrationId: string;
+    data: ChatAnalyticsLiveInterruptedEvent;
+}
+/**
+ * @public
+ */
+export interface WebhookChatLiveProgressEvent {
+    id: string;
+    pbx?: string;
+    company?: string;
+    type: WebhookEventType;
+    time: number;
+    integrationId: string;
+    data: ChatAnalyticsLiveProgressEvent;
+}
+/**
+ * @public
+ */
+export interface WebhookChatManagerMissedEvent {
+    id: string;
+    pbx?: string;
+    company?: string;
+    type: WebhookEventType;
+    time: number;
+    integrationId: string;
+    data: ChatAnalyticsManagerMissedEvent;
+}
+/**
+ * @public
+ */
+export interface WebhookConferenceCompletedEvent {
+    id: string;
+    pbx?: string;
+    company?: string;
+    type: WebhookEventType;
+    time: number;
+    integrationId: string;
+    data: ConferenceAnalyticsRecordEvent;
+}
+/**
+ * @public
+ */
+export interface WebhookConferenceLiveCompletedEvent {
+    id: string;
+    pbx?: string;
+    company?: string;
+    type: WebhookEventType;
+    time: number;
+    integrationId: string;
+    data: ConferenceAnalyticsLiveCompleteEvent;
+}
+/**
+ * @public
+ */
+export interface WebhookConferenceLiveInterruptedEvent {
+    id: string;
+    pbx?: string;
+    company?: string;
+    type: WebhookEventType;
+    time: number;
+    integrationId: string;
+    data: ConferenceAnalyticsLiveInterruptedEvent;
+}
+/**
+ * @public
+ */
+export interface WebhookConferenceLiveJoinEvent {
+    id: string;
+    pbx?: string;
+    company?: string;
+    type: WebhookEventType;
+    time: number;
+    integrationId: string;
+    data: ConferenceAnalyticsLiveJoinEvent;
+}
+/**
+ * @public
+ */
+export interface WebhookConferenceLiveLeaveEvent {
+    id: string;
+    pbx?: string;
+    company?: string;
+    type: WebhookEventType;
+    time: number;
+    integrationId: string;
+    data: ConferenceAnalyticsLiveLeaveEvent;
+}
+/**
+ * @public
+ */
+export interface WebhookConferenceLiveProgressEvent {
+    id: string;
+    pbx?: string;
+    company?: string;
+    type: WebhookEventType;
+    time: number;
+    integrationId: string;
+    data: ConferenceAnalyticsLiveProgressEvent;
+}
+/**
+ * @public
+ */
+export interface WebhookConferenceLiveTranscriptionEvent {
+    id: string;
+    pbx?: string;
+    company?: string;
+    type: WebhookEventType;
+    time: number;
+    integrationId: string;
+    data: ConferenceAnalyticsLiveTranscriptionEvent;
+}
+/**
+ * @public
+ */
+export interface WebhookOutdatedCallParticipant {
+    type: string;
+    phone?: string;
+    name?: string;
+    company?: string;
+    email?: string;
+    userId?: string;
+    userExtension?: string;
+    userDepartment?: string;
+    groupId?: string;
+    groupName?: string;
+    userAgent?: string;
+    userDevice?: CallDevice;
+    role: string;
+    license?: string;
+}
+/**
+ * @public
+ */
+export interface WebhookOutdatedCallEventData {
+    status?: string;
+    caller?: WebhookOutdatedCallParticipant;
+    callee?: WebhookOutdatedCallParticipant;
+    service?: string;
+    destination?: string;
+    trunkName?: string;
+    queueId?: string;
+    queueName?: string;
+    tags: (string)[];
+    flags: (string)[];
+    endCause?: string;
+    endCauseStr?: string;
+    endBy?: string;
+}
+/**
+ * @public
+ */
+export interface WebhookOutdatedCallEndEvent {
+    id: string;
+    pbx?: string;
     company?: string;
-    bot?: boolean;
-    pbxDomain?: string;
-    pbxPort?: string;
-    pbxExtension?: string;
-    pbxSerial?: string;
-    pbxUserId?: string;
-    createdAt?: string;
-    updatedAt?: string;
+    type: WebhookEventType;
+    time: number;
+    integrationId: string;
+    data: WebhookOutdatedCallEventData;
+}
+/**
+ * @public
+ */
+export interface WebhookOutdatedCallStartEvent {
+    id: string;
+    pbx?: string;
+    company?: string;
+    type: WebhookEventType;
+    time: number;
+    integrationId: string;
+    data: WebhookOutdatedCallEventData;
+}
+/**
+ * @public
+ */
+export interface WebhookOutdatedCallUpdateEvent {
+    id: string;
+    pbx?: string;
+    company?: string;
+    type: WebhookEventType;
+    time: number;
+    integrationId: string;
+    data: WebhookOutdatedCallEventData;
+}
+/**
+ * @public
+ */
+export interface WebhookPresenceConferenceEventData {
+    extension: string;
+    isJoined: boolean;
+    isLeaved: boolean;
+    participant: ConferenceParticipant;
+}
+/**
+ * @public
+ */
+export interface WebhookPresenceConferenceEvent {
+    id: string;
+    pbx?: string;
+    company?: string;
+    type: WebhookEventType;
+    time: number;
+    integrationId: string;
+    data: WebhookPresenceConferenceEventData;
+}
+/**
+ * @public
+ */
+export interface WebhookPresenceTelephonyEventData {
+    extension: string;
+    email: string;
+    sourceId: string;
+    status: string;
+}
+/**
+ * @public
+ */
+export interface WebhookPresenceTelephonyEvent {
+    id: string;
+    pbx?: string;
+    company?: string;
+    type: WebhookEventType;
+    time: number;
+    integrationId: string;
+    data: WebhookPresenceTelephonyEventData;
+}
+/**
+ * @public
+ */
+export interface WebhookPresenceUserEventLocationData {
+    address: string;
+    lat: string;
+    lng: string;
+}
+/**
+ * @public
+ */
+export interface WebhookPresenceUserEventData {
+    extension: string;
+    email: string;
+    sourceId: string;
+    status: string;
+    until: string;
+    message: string;
+    location: WebhookPresenceUserEventLocationData;
+}
+/**
+ * @public
+ */
+export interface WebhookPresenceUserEvent {
+    id: string;
+    pbx?: string;
+    company?: string;
+    type: WebhookEventType;
+    time: number;
+    integrationId: string;
+    data: WebhookPresenceUserEventData;
 }
 /**
  * @public
  * @enum
  */
-export declare const ChannelType: {
-    readonly DIRECT: "direct";
-    readonly GROUP: "group";
+export declare const WebsocketEvent: {
+    readonly AUTHORIZED: "authorized";
+    readonly BROADCAST: "broadcast";
+    readonly SUBSCRIBED: "subscribed";
 };
 /**
  * @public
  */
-export type ChannelType = typeof ChannelType[keyof typeof ChannelType];
+export type WebsocketEvent = typeof WebsocketEvent[keyof typeof WebsocketEvent];
+/**
+ * @public
+ * @enum
+ */
+export declare const WebsocketTopic: {
+    readonly CONVERSATIONS: "conversations";
+    readonly PRESENCE: "presence";
+    readonly TRANSCRIPTIONS: "transcriptions";
+};
+/**
+ * @public
+ */
+export type WebsocketTopic = typeof WebsocketTopic[keyof typeof WebsocketTopic];
+/**
+ * @public
+ */
+export interface WebsocketConversationsBroadcastEvent {
+    event: WebsocketEvent;
+    topic: WebsocketTopic;
+    data: __DocumentType;
+    meta?: __DocumentType;
+}
+/**
+ * @public
+ */
+export interface WebsocketPresenceData {
+    id?: string;
+    company?: string;
+    extension?: string;
+    status?: string;
+    telephony?: string;
+    conference?: string;
+    message?: string;
+    until?: string;
+    address?: string;
+    lng?: string;
+    lat?: string;
+    seen?: string;
+}
+/**
+ * @public
+ */
+export interface WebsocketPresenceDataList {
+    member?: WebsocketPresenceData;
+}
+/**
+ * @public
+ */
+export interface WebsocketPresenceBroadcastEvent {
+    event: WebsocketEvent;
+    topic: WebsocketTopic;
+    delta?: WebsocketPresenceData;
+    data?: WebsocketPresenceDataList;
+    meta?: __DocumentType;
+}
+/**
+ * @public
+ */
+export interface WebsocketTranscriptionsBroadcastEvent {
+    event: WebsocketEvent;
+    topic: WebsocketTopic;
+    data: __DocumentType;
+    meta?: __DocumentType;
+}
+/**
+ * @public
+ */
+export interface DescribeEventOutput {
+    CallAnalyticsLiveProgressEvent?: CallAnalyticsLiveProgressEvent;
+    CallAnalyticsLiveCompleteEvent?: CallAnalyticsLiveCompleteEvent;
+    CallAnalyticsLiveInterruptedEvent?: CallAnalyticsLiveInterruptedEvent;
+    CallAnalyticsLiveTranscriptionEvent?: CallAnalyticsLiveTranscriptionEvent;
+    CallAnalyticsRecordEvent?: CallAnalyticsRecordEvent;
+    CallAnalyticsTranscriptionRecordEvent?: CallAnalyticsTranscriptionRecordEvent;
+    CallAnalyticsCostRecordEvent?: CallAnalyticsCostRecordEvent;
+    ChatAnalyticsLiveCompleteEvent?: ChatAnalyticsLiveCompleteEvent;
+    ChatAnalyticsLiveInterruptedEvent?: ChatAnalyticsLiveInterruptedEvent;
+    ChatAnalyticsLiveMissedEvent?: ChatAnalyticsLiveMissedEvent;
+    ChatAnalyticsLiveProgressEvent?: ChatAnalyticsLiveProgressEvent;
+    ChatAnalyticsManagerMissedEvent?: ChatAnalyticsManagerMissedEvent;
+    ChatAnalyticsRecordEvent?: ChatAnalyticsRecordEvent;
+    ConferenceAnalyticsLiveProgressEvent?: ConferenceAnalyticsLiveProgressEvent;
+    ConferenceAnalyticsLiveCompleteEvent?: ConferenceAnalyticsLiveCompleteEvent;
+    ConferenceAnalyticsLiveInterruptedEvent?: ConferenceAnalyticsLiveInterruptedEvent;
+    ConferenceAnalyticsLiveTranscriptionEvent?: ConferenceAnalyticsLiveTranscriptionEvent;
+    ConferenceAnalyticsLiveJoinEvent?: ConferenceAnalyticsLiveJoinEvent;
+    ConferenceAnalyticsLiveLeaveEvent?: ConferenceAnalyticsLiveLeaveEvent;
+    ConferenceAnalyticsRecordEvent?: ConferenceAnalyticsRecordEvent;
+    ConferenceAnalyticsTranscriptionRecordEvent?: ConferenceAnalyticsTranscriptionRecordEvent;
+    PresenceAnalyticsStatusEvent?: PresenceAnalyticsStatusEvent;
+    PresenceAnalyticsConferenceEvent?: PresenceAnalyticsConferenceEvent;
+    PresenceAnalyticsTelephonyEvent?: PresenceAnalyticsTelephonyEvent;
+    WebsocketPresenceBroadcastEvent?: WebsocketPresenceBroadcastEvent;
+    WebsocketConversationsBroadcastEvent?: WebsocketConversationsBroadcastEvent;
+    WebsocketTranscriptionsBroadcastEvent?: WebsocketTranscriptionsBroadcastEvent;
+    WebhookPresenceUserEvent?: WebhookPresenceUserEvent;
+    WebhookPresenceTelephonyEvent?: WebhookPresenceTelephonyEvent;
+    WebhookPresenceConferenceEvent?: WebhookPresenceConferenceEvent;
+    WebhookCallLiveProgressEvent?: WebhookCallLiveProgressEvent;
+    WebhookCallLiveCompletedEvent?: WebhookCallLiveCompletedEvent;
+    WebhookCallLiveInterruptedEvent?: WebhookCallLiveInterruptedEvent;
+    WebhookCallLiveTranscriptionEvent?: WebhookCallLiveTranscriptionEvent;
+    WebhookCallCompletedEvent?: WebhookCallCompletedEvent;
+    WebhookConferenceLiveProgressEvent?: WebhookConferenceLiveProgressEvent;
+    WebhookConferenceLiveCompletedEvent?: WebhookConferenceLiveCompletedEvent;
+    WebhookConferenceLiveInterruptedEvent?: WebhookConferenceLiveInterruptedEvent;
+    WebhookConferenceLiveJoinEvent?: WebhookConferenceLiveJoinEvent;
+    WebhookConferenceLiveLeaveEvent?: WebhookConferenceLiveLeaveEvent;
+    WebhookConferenceLiveTranscriptionEvent?: WebhookConferenceLiveTranscriptionEvent;
+    WebhookConferenceCompletedEvent?: WebhookConferenceCompletedEvent;
+    WebhookChatLiveProgressEvent?: WebhookChatLiveProgressEvent;
+    WebhookChatLiveCompletedEvent?: WebhookChatLiveCompletedEvent;
+    WebhookChatLiveInterruptedEvent?: WebhookChatLiveInterruptedEvent;
+    WebhookChatManagerMissedEvent?: WebhookChatManagerMissedEvent;
+    WebhookChatCompletedEvent?: WebhookChatCompletedEvent;
+    WebhookOutdatedCallStartEvent?: WebhookOutdatedCallStartEvent;
+    WebhookOutdatedCallUpdateEvent?: WebhookOutdatedCallUpdateEvent;
+    WebhookOutdatedCallEndEvent?: WebhookOutdatedCallEndEvent;
+    CallEventType?: CallEventType;
+    ConferenceEventType?: ConferenceEventType;
+    ChatEventType?: ChatEventType;
+    PresenceEventType?: PresenceEventType;
+}
 /**
  * @public
  */
@@ -236,17 +1849,6 @@ export interface ChannelContext {
     target?: string;
     events?: (ChannelContextEvent)[];
 }
-/**
- * @public
- * @enum
- */
-export declare const ChannelWhatsAppStatus: {
-    readonly CHANNEL_CLOSED: "24h_channel_closed";
-};
-/**
- * @public
- */
-export type ChannelWhatsAppStatus = typeof ChannelWhatsAppStatus[keyof typeof ChannelWhatsAppStatus];
 /**
  * @public
  */
@@ -279,8 +1881,6 @@ export interface Channel {
     telephony?: boolean;
     sms?: boolean;
     mms?: boolean;
-    whatsapp?: boolean;
-    whatsappStatus?: ChannelWhatsAppStatus;
     broadcast?: boolean;
     external?: boolean;
     channelId: string;
@@ -633,20 +2233,6 @@ export declare const MessageType: {
  * @public
  */
 export type MessageType = typeof MessageType[keyof typeof MessageType];
-/**
- * @public
- * @enum
- */
-export declare const MessageWhatsAppStatus: {
-    readonly DELIVERED: "delivered";
-    readonly ERROR: "error";
-    readonly SENT: "sent";
-    readonly TRYING: "trying";
-};
-/**
- * @public
- */
-export type MessageWhatsAppStatus = typeof MessageWhatsAppStatus[keyof typeof MessageWhatsAppStatus];
 /**
  * @public
  */
@@ -661,8 +2247,6 @@ export interface Message {
     event?: string;
     sms?: boolean;
     smsStatus?: MessageSmsStatus;
-    whatsapp?: boolean;
-    whatsappStatus?: MessageWhatsAppStatus;
     messageId: string;
     channelId: string;
     user: User;