# Smart Embed Event Reference

<!-- WARNING: THIS FILE WAS AUTOGENERATED! DO NOT EDIT! -->

Zoom Contact Center Smart Embed communicates with your web application through browser `postMessage` events. This reference documents all available events, organized by feature category.

## Initialization and Configuration

These events handle the initial setup and configuration of Smart Embed when it loads in your web application.

### zcc-init-config-request

This event fires when an agent loads a webpage with Smart Embed.

```javascript
{
    type: "zcc-init-config-request",
}
```

### zcc-init-config-response

Send this event in response to `zcc-init-config-request` to provide your Smart Embed configuration settings.

```javascript
{
    type: "zcc-init-config-response",
    data: {
        phone: {
            screenPopEvent: "RINGING",
        },
    },
}
```

### zcc-agent-info-request

Send this event to retrieve the authenticated agent's identity from Smart Embed on demand.

Use this when your listener was not attached at login, or when you need to refresh the cached identity.

The `requestId` is optional and will be echoed on `zcc-agent-info-response`, or on `zcc-error` if login has not completed.

Smart Embed responds with `zcc-agent-info-response`.

If the agent is not authenticated, Smart Embed responds with `zcc-error` with code `agent-not-authenticated` and message 'Agent identity is available only after login.'

```javascript
{
    type: "zcc-agent-info-request",
    data: {
        requestId: REQUEST_ID, // optional
    },
}
```

### zcc-agent-info-response

This event fires after the agent successfully authenticates in Smart Embed, at the same time as `zcc-init-config-request`.

It also fires in response to `zcc-agent-info-request`, so hosts that attach a listener after login can still retrieve the same identity.

Smart Embed does not send this event before login completes.

`agentId` matches the `agentId` on `zcc-call-connected` and `zcc-outbound-call-started`, so you can correlate identity with call events.

The `firstName` and `lastName` fields come from the agent's profile. If those fields are missing, Smart Embed splits the display name.

The `email` field may be an empty string if it is not set on the profile.

When this event is a response to `zcc-agent-info-request`, `requestId` echoes the value from the request.

```javascript
{
    type: "zcc-agent-info-response",
    data: {
        agentId: AGENT_ID,
        firstName: AGENT_FIRST_NAME,
        lastName: AGENT_LAST_NAME,
        email: AGENT_EMAIL,
        requestId: REQUEST_ID, // present only when responding to zcc-agent-info-request
    },
}
```

### zcc-resize

This event fires when a user toggles the size buttons in Smart Embed.

Use this to resize your web application.

```javascript
{
    type: "zcc-resize",
    data: {
        widthInPixels,
        heightInPixels,
    },
};
```

## Contact Search

These events let Smart Embed search for and link contact records from your CRM or web application.

### zcc-contact-search-event

This event fires when Smart Embed needs to resolve phone numbers or email addresses against your web application.

This can happen when the agent types in the Smart Embed dialpad's `Phone` or `User` field, or when Smart Embed loads with existing engagements that need to be linked to your web application.

```javascript
{
    type: "zcc-contact-search-event",
    data: {
        query: "DATA_TO_SEARCH", // could be a phone number, first name, last name, email, etc.
    },
}
```

### zcc-contact-search-response

Send this event in response to `zcc-contact-search-event` to provide matching contact information.

Search for user, contact, lead, or similar objects in your application based on the query field.

Smart Embed displays this data to the agent in the Smart Embed UI.

```javascript
{
    type: "zcc-contact-search-response",
    data: {
        id: "THIRD_PARTY_ID",   // This is displayed visually to the Contact Center agent in the Smart Embed UI
        name: "NAME",           // This is displayed visually to the Contact Center agent in the Smart Embed UI
        phone: "PHONE_NUMBER",  // Phone number for the user, contact, lead, etc
        email: "YOUR_STRING",   // Email address for the user, contact, lead, etc
        entity: "YOUR_STRING",  // The type of entity used by your application, for example contact/lead/user/etc. Smart Embed uses this to display to the Contact Center agent, but does not use this for any other purpose.
    },
}
```

### zcc-incomingPhone-request

This event fires when an agent gets an incoming call.

It supports the voice channel and the SMS channel.

```javascript
{
    type: "zcc-incomingPhone-request",
    data: {
        incomingPhoneNumber: YOUR_CALLER_PHONE_NUMBER,
        engagementId: YOUR_CALL_ENGAGEMENT_ID,
        channel: "voice",  // Possible values: 'voice', 'sms'
    },
}
```

### zcc-incomingPhone-response

Send this event in response to `zcc-incomingPhone-request` to provide matching contact information.

Search for matching contact records in your application. If there are multiple matches, Smart Embed displays them to the agent to select the appropriate match. If there is no match, respond with an empty array.

This data is also included in the `zcc-phone-call-log` event for CRM logging.

```javascript
{
    type: "zcc-incomingPhone-response",
    data: [
        {
            id: YOUR_ID,
            name: YOUR_NAME,
            phone: YOUR_PHONE_NUMBER,
            email: YOUR_EMAIL_ID,
            entity: YOUR_ENTITY, // the type of entity used by your application, such as contact, lead, user, etc.
        },
    ],
}
```

### zcc-incomingEmail-request

This event fires when an agent gets an incoming chat or video message.

It supports the video and chat channels.

```javascript
{
    type: "zcc-incomingEmail-request",
    data: {
        email: CONSUMERS_EMAIL,
        engagementId: ENGAGEMENT_ID,
        channel: "chat",  // Possible values: 'chat', 'video'
    },
}
```

### zcc-incomingEmail-response

Send this event in response to `zcc-incomingEmail-request` to provide matching contact information.

Search for matching contact records in your application.

If there are multiple matches, Smart Embed displays them to the agent to select the appropriate match.

If there is no match, respond with an empty array.

```javascript
{
    type: "zcc-incomingEmail-response",
    data: [
        {
            id: ID,
            name: NAME,
            phone: PHONE_NUMBER,
            email: EMAIL_ID,
            entity: ENTITY,
        },
    ],
}
```

### zcc-screen-pop

This event fires when an agent selects a contact from multiple matches.

When an incoming call includes multiple contact, lead, or user objects in the `zcc-incomingPhone-response` array, Smart Embed presents them to the agent.

When the agent identifies and selects the appropriate object, this event fires so your application can screen pop to the correct record.

Use the `id` to search for the matching record and perform a screen pop.

```javascript
{
    type: "zcc-screen-pop",
    data: {
        id: ID_NUMBER,
    },
}
```

## Voice Call Lifecycle

These events track the lifecycle of voice calls from ringing to completion, including call logging and recording.

### zcc-call-ringing

This event fires when an agent receives a call.

```javascript
{
    type: "zcc-call-ringing",
    data: {
        channel: <create ts number>,
        createTs: <create ts number>,
        engagementId: YOUR_CALL_ENGAGEMENT_ID,
        from: YOUR_CALLER_PHONE_NUMBER,
        queueName: YOUR_QUEUE_NAME,
        to: YOUR_CALLEE_PHONE_NUMBER,
        isConference: <true | false if conference>,
        isTransfer: <true | false if transfer>,
    },
}
```

### zcc-call-connected

This event fires when a call is accepted.

```javascript
{
    type: "zcc-call-connected",
    data: {
        acceptTs: ACCEPT_TS_NUMBER,
        direction: <inbound | outbound>,
        engagementId: ENGAGEMENT_ID,
        from: CALLER_PHONE_NUMBER,
        queueId: THE_QUEUE_ID,
        queueName: THE_QUEUE_NAME,
        to: CALLEES_PHONE_NUMBER,
        agentId: AGENT_ID,
    },
}
```

### zcc-call-ended

This event fires when a call ends.

```javascript
{
    type: "zcc-call-ended",
    data: {
        completeTs: COMPLETE_TS_NUMBER,
        engagementId: ENGAGEMENT_ID,
        direction: <inbound | outbound>,
    },
}
```

### zcc-outbound-call-started

This event fires when an agent starts an outbound voice call to a consumer.

```javascript
{
    type: "zcc-outbound-call-started",
    data: {
        "engagementId": ENGAGEMENT_ID,
        "from": CALLER_PHONE_NUMBER,
        "to": CALLEES_PHONE_NUMBER,
        "queueName": QUEUE_NAME,
        "startTs": OB_START_TIMESTAMP
    },
};
```

### zcc-inbound-not-connected

This event fires when an inbound call is missed, rejected, or declined by an agent.

```javascript
{
    type: "zcc-inbound-not-connected",
    data: {
        engagementId: ENGAGEMENT_ID,
        reasonCode: REASON_CODE,
        message: REASON_MESSAGE,
    },
};
```

### zcc-outbound-not-connected

This event fires when an outbound call cannot be placed due to an unserviced phone number.

This event does not fire when a call is sent to voicemail.

```javascript
{
    type: "zcc-outbound-not-connected",
    data: {
        engagementId: ENGAGEMENT_ID,
        reasonCode: REASON_CODE,
        message: REASON_MESSAGE,
    },
};
```

### zcc-call-recording

This event fires when an agent completes an engagement.

Store this URL in your application for agents to play back recordings.

Accessing these URLs requires the user to be signed into Smart Embed and to have access permissions to playback the recording from the Contact Center admin portal.

```javascript
{
    type: "zcc-call-recording",
    data: {
        engagementId: ENGAGEMENT_ID,
        recordingUrl: RECORDING_URL,
    },
}
```

### zcc-phone-call-log

This event fires when an agent completes an engagement.

Use this event to create logs for all engagement types within your application.

```javascript
{
    type: "zcc-phone-call-log",
    data: {
        objectRecord: {
            callType: <inbound | outbound>,
            from: <caller number>,
            to: <callee number>,
            callDuration: <call duration time>,
            callStartTime: <call start time>,
            callEndTime: <call end time>,
            callQueue: <call queue>,
            agentExtension: <agent extension>,
            agentName: <name of agent>,
            wrapUpTimeDuration: <time taken while doing wrapup>,
            notes: [ <array of notes in HTML format, entered by agent> ],
            dispositionCode: <disposition code selected by agent>,
            dispositionId: <id of the disposition code>,
            type: <phone | chat>,
        },
        engagementId: ENGAGEMENT_ID,
        relateTo: <>,
        smartNotes: [ <array of notes in HTML format, generated by Zoom AI Expert Assist> ],
        channelUpgradeInfo: <Information regarding any channel upgrades that occurred during the engagement>,
        user: {
            id: <consumer's ID, data comes from info received from event zcc-incomingPhone-response>,
            name: <consumer's name, from event zcc-incomingPhone-response>,
            phone: <consumer's phone number, from event zcc-incomingPhone-response>,
            email: <consumer's email, from event zcc-incomingPhone-response>,
            entity: <consumer's entity type, from event zcc-incomingPhone-response>,
        },
    },
}
```

### Click to dial from a third-party app

Send this event to make a call when a user selects a phone number in your web application.

```javascript
{
    type: "onclicktoact",
    data: {
        id: USERS_THIRD_PARTY_ID,
        name: USER_NAME,
        phone: USER_PHONE_NUMBER,       // required field for outbound voice channel calls
        email: EMAIL_OPTIONAL_FIELD,
        userEntity: USERS_ENTITY_TYPE,  // such as user or contact
    },
}
```

Example implementation:

```javascript
window.frames["zoom-embeddable-phone-iframe"].contentWindow.postMessage(
    {
        type: "onclicktoact",
        data: {
            phone: "+16505551234",
        },
    },
    "*",
);
```

## Chat Events

These events manage web chat engagements from ringing to completion.

### zcc-chat-ringing

This event fires when an agent receives an inbound web chat engagement.

```javascript
{
    type: "zcc-chat-ringing",
    data: {
        queueId: QUEUE_ID,
        queueName: QUEUE_NAME,
        engagementId:ENGAGEMENT_ID,
        customerName: CUSTOMER_NAME,
        customerEmail: CUSTOMER_EMAIL,
    },
}
```

### zcc-chat-started

This event fires when an agent accepts a chat and the app loads the chat window.

```javascript
{
    type: "zcc-chat-started",
    data: {
        engagementId: ENGAGEMENT_ID,
        createTs: CHAT_START_DATE_AND_TIME,
    },
}
```

### zcc-chat-ended

This event fires when an agent or consumer ends a chat.

```javascript
{
    type: "zcc-chat-ended",
    data: {
        engagementId: ENGAGEMENT_ID,
        completeTs: CHAT_END_DATE_AND_TIME,
    },
}
```

### zcc-send-chat-message

Send this event to send a chat message from your application.

`channelType` must be `chat` and `messagePayload` must include `textBody`.

Optional fields: `conversationId`, `communicationId`, and `participantId`.

```javascript
{
    type: "zcc-send-chat-message",
    data: {
        engagementId: ENGAGEMENT_ID,
        channelType: "chat",
        requestId: REQUEST_ID,
        messagePayload: {
            textBody: "Hello"
        },
        conversationId: CONVERSATION_ID, // optional
        communicationId: COMMUNICATION_ID, // optional
        participantId: PARTICIPANT_ID, // optional
    },
}
```

### zcc-send-chat-message-response

Smart Embed responds with this event after a `zcc-send-chat-message` request.

`status` is `true` on success or `false` on failure with `errorCode` and `errorMessage`.

```javascript
{
    type: "zcc-send-chat-message-response",
    data: {
        requestId: REQUEST_ID,
        status: true,
        timestamp: TIMESTAMP_MS, // optional, success
    },
}
```

## Video Events

These events manage video engagements, including upgrading voice calls to video.

### zcc-video-ringing

This event fires when an agent receives an inbound video engagement.

```javascript
{
    type: "zcc-video-ringing",
    data: {
        queueId: QUEUE_ID,
        queueName: QUEUE_NAME,
        engagementId: ENGAGEMENT_ID,
    }
}
```

### zcc-video-started

This event fires when an agent accepts an inbound or outbound video engagement.

```javascript
{
    type: "zcc-video-started",
    data: {
        engagementId: ENGAGEMENT_ID,
        createTs: VIDEO_START_DATE_AND_TIME,
    },
}
```

### zcc-video-ended

This event fires when an agent ends an inbound or outbound video engagement.

```javascript
{
    type: "zcc-video-ended",
    data: {
        engagementId: ENGAGEMENT_ID,
        completeTs: VIDEO_END_DATE_AND_TIME,
    },
}
```

### zcc-upgrade-to-video

Send this event to upgrade an active voice engagement to video.

`method` must be `sms`, `email`, or `manual` (case-insensitive). `destination` is required for the email method.

The SMS method may resolve the phone number from the current call.

```javascript
{
    type: "zcc-upgrade-to-video",
    data: {
        engagementId: ENGAGEMENT_ID,
        channelType: "voice",
        requestId: REQUEST_ID,
        method: "email", // "sms" | "email"
        destination: PHONE_OR_EMAIL,
    },
}
```

## SMS Events

These events manage SMS chat engagements from ringing to completion.

### zcc-sms-ringing

This event fires when an agent receives an inbound SMS chat engagement.

```javascript
{
    type: "zcc-sms-ringing",
    data: {
        queueId: QUEUE_ID,
        queueName: QUEUE_NAME,
        engagementId:ENGAGEMENT_ID,
        customerName: CUSTOMER_NAME,
        customerEmail: CUSTOMER_EMAIL,
        incomingPhoneNumber: CUSTOMER_PHONE,
    },
}
```

### zcc-sms-started

This event fires when an agent accepts an SMS engagement and the chat window is loaded.

```javascript
{
    type: "zcc-sms-started",
    data: {
        engagementId: ENGAGEMENT_ID,
        createTs: SMS_START_DATE_AND_TIME,
    },
}
```

### zcc-sms-ended

This event fires when an agent or consumer ends an SMS engagement.

```javascript
{
    type: "zcc-sms-ended",
    data: {
        engagementId: ENGAGEMENT_ID,
        completeTs: SMS_END_DATE_AND_TIME,
    },
}
```

## Engagement Management

These events control engagement state, including accepting, rejecting, terminating, and managing wrap-up.

### zcc-reject-engagement

Send this event to reject an inbound engagement.

Required fields:

-   `engagementId`
-   `channelType`
-   `requestId`

The `engagementId` must reference a valid engagement, and the `channelType` must be `voice`, `video`, `chat`, or `sms`.

The `requestId` must be a unique, 128-bit UUID for tracking.

```javascript
{
    type: "zcc-reject-engagement",
    data: {
        engagementId: ENGAGEMENT_ID,
        channelType: CHANNEL_TYPE,
        requestId: UNIQUE_REQUEST_ID,
    },
};
```

### zcc-accept-engagement

Send this event to accept an incoming engagement.

Required fields:

-   `engagementId`
-   `channelType`
-   `requestId`

The `engagementId` must reference a valid engagement, and the `channelType` must be `voice`, `video`, `chat`, or `sms`.

The `requestId` must be a unique, 128-bit UUID for tracking.

```javascript
{
    type: "zcc-accept-engagement",
    data: {
        engagementId: ENGAGEMENT_ID,
        channelType: CHANNEL_TYPE,
        requestId: UNIQUE_REQUEST_ID,
    },
};
```

### zcc-terminate-engagement

Send this event to terminate an active engagement.

Required fields:

-   `engagementId`
-   `channelType`
-   `requestId`

The `engagementId` must reference an active engagement, and the `channelType` must be `voice`, `video`, `chat`, or `sms`.

The `requestId` must be a unique, 128-bit UUID for tracking.

```javascript
{
    type: "zcc-terminate-engagement",
    data: {
        engagementId: ENGAGEMENT_ID,
        channelType: CHANNEL_TYPE,
        requestId: UNIQUE_REQUEST_ID,
    },
};
```

### zcc-set-engagement-disposition

Send this event to select an engagement's wrap-up disposition.

Required fields:

-   `engagementId`
-   `channelType`
-   `dispositionId`
-   `requestId`

The `engagementId` must reference an engagement in `post engagement` or `wrap-up` state, and the `channelType` must be `voice`, `video`, `chat`, or `sms`.

The `dispositionId` should be the unique ID of a valid, pre-configured Contact Center disposition code.

The `requestId` must be a unique, 128-bit UUID for tracking.

```javascript
{
    type: "zcc-set-engagement-disposition",
    data: {
        engagementId: ENGAGEMENT_ID,
        channelType: CHANNEL_TYPE,
        requestId: UNIQUE_REQUEST_ID,
        dispositionId:  DISPOSITION_ID,
    },
};
```

### zcc-close-engagement-wrapup

Send this event to complete an engagement or end engagement `wrap-up`.

Required fields:

-   `engagementId`
-   `channelType`
-   `requestId`

The `engagementId` must reference an engagement in `post engagement` or `wrap-up` state, and the `channelType` must be `voice`, `video`, `chat`, or `sms`.

The `requestId` must be a unique, 128-bit UUID for tracking.

```javascript
{
    type: "zcc-close-engagement-wrapup",
    data: {
        engagementId: ENGAGEMENT_ID,
        channelType: CHANNEL_TYPE,
        requestId: UNIQUE_REQUEST_ID,
        note: string, // maximum 2000
    },
};
```

### zcc-engagement-status-request

Send this event to retrieve engagement details.

The `requestId` must be a unique, 128-bit UUID for tracking.

The `engagementId` is optional. If provided, it must reference a valid engagement.

```javascript
{
    type: "zcc-engagement-status-request",
    data: {
        engagementId: ENGAGEMENT_ID,
        requestId: UNIQUE_REQUEST_ID,
    },
};
```

### zcc-engagement-status-response

Smart Embed responds with this event after a `zcc-engagement-status-request`.

Without an `engagementId` in the request, the event returns all available engagements in both `active` and `wrap-up` state.

With an `engagementId`, the event returns only the specified engagement.

Included fields depend on engagement channel and data availability.

```javascript
{
    type: "zcc-engagement-status-response",
    data: {
         requestId: UNIQUE_REQUEST_ID,
         active: [
              {
                engagementId: ENGAGEMENT_ID
                channel: ENGAGEMENT_CHANNEL
                engagementDirection: ENGAGEMENT_DIRECTION
                state: ENGAGEMENT_STATE // 'active'
                isOnHold: true, // or false (voice channel only)
                queueId: THE_QUEUE_ID
                queueName: THE_QUEUE_ID
                customerNumber: CUSTOMER_PHONE_NUMBER
                customerName: CUSTOMER_NAME
                customerEmail: CUSTOMER_EMAIL
                from: CALLER_PHONE_NUMBER,
                to: CALLEES_PHONE_NUMBER,
              }
            ],
         wrapup: [
              {
                engagementId: ENGAGEMENT_ID
                channel: ENGAGEMENT_CHANNEL
                engagementDirection: ENGAGEMENT_DIRECTION
                state: ENGAGEMENT_STATE // 'wrapup'
                queueId: THE_QUEUE_ID
                queueName: THE_QUEUE_ID
                customerNumber: CUSTOMER_PHONE_NUMBER
                customerName: CUSTOMER_NAME
                customerEmail: CUSTOMER_EMAIL
                from: CALLER_PHONE_NUMBER,
                to: CALLEES_PHONE_NUMBER,
            }
         ],
    },
};
```

### zcc-engagement-log-url

This event fires when a wrap-up is saved and the Event Logging feature is set to automatic save.

The event contains the `engagementId` and a URL to a page with engagement information.

The page includes recordings, transcripts, and QM recordings.

```javascript
{
    type: "zcc-close-engagement-wrapup",
    data: {
        engagementId: ENGAGEMENT_ID,
        recordingUrl: PAGE_URL,
    },
};
```

### zcc-end-post-engagement (Deprecated)

This event is deprecated. Use `zcc-set-engagement-disposition` and `zcc-close-engagement-wrapup` instead.

```javascript
{
    type: "zcc-end-post-engagement",
    data: {
        name: YOUR_DISPOSITION,
        engagementId: ENGAGEMENT_ID,
    },
}
```

## In-Call Controls

These events control active voice calls, including mute, hold, DTMF, and recording.

### zcc-set-mute

Send this event to mute or unmute the agent's microphone on an active voice engagement.

Required fields:

-   `engagementId`
-   `channelType` (must be `"voice"`)
-   `requestId`
-   `mute` (boolean)

Validation failures return `zcc-error` with code `invalid-input`.

```javascript
{
    type: "zcc-set-mute",
    data: {
        engagementId: ENGAGEMENT_ID,
        channelType: "voice",
        requestId: REQUEST_ID,
        mute: true, // or false
    },
}
```

### zcc-set-hold

Send this event to place the voice call on hold or resume it.

Required fields:

-   `engagementId`
-   `channelType` (must be `"voice"`)
-   `requestId`
-   `hold` (boolean)

Validation failures return `zcc-error` with code `invalid-input`.

```javascript
{
    type: "zcc-set-hold",
    data: {
        engagementId: ENGAGEMENT_ID,
        channelType: "voice",
        requestId: REQUEST_ID,
        hold: true, // or false
    },
}
```

### zcc-set-hold-response

Smart Embed responds with this event after a `zcc-set-hold` request.

`status` is `true` on success or `false` on failure, and `isOnHold` indicates the current hold state.

```javascript
{
    type: "zcc-set-hold-response",
    data: {
        requestId: REQUEST_ID,
        status: true, // or false on failure
        engagementId: ENGAGEMENT_ID,
        channelType: "voice",
        isOnHold: true, // current hold state
        timestamp: TIMESTAMP_MS,
    },
}
```

### zcc-send-dtmf

Send this event to transmit a single DTMF digit into the active voice call. `digit` must be one character from among 0–9, \*, or #.

```javascript
{
    type: "zcc-send-dtmf",
    data: {
        engagementId: ENGAGEMENT_ID,
        channelType: "voice",
        requestId: REQUEST_ID,
        digit: "1",
    },
}
```

### zcc-set-recording

Send this event to pause, resume, or stop in-call recording on voice. `action` is case-insensitive.

```javascript
{
    type: "zcc-set-recording",
    data: {
        engagementId: ENGAGEMENT_ID,
        channelType: "voice",
        requestId: REQUEST_ID,
        action: "pause", // "resume" | "stop"
    },
}
```

## Transfer and Conference

These events manage call transfers and conference operations, including getting target lists and controlling consult legs.

### zcc-get-target-list

Send this event to request the list of available transfer targets (agents, queues, flows) for transferring or conferencing a call.

```javascript
{
    type: "zcc-get-target-list",
    data: {
        requestId: REQUEST_ID,
    },
}
```

### zcc-target-list-response

Smart Embed responds with this event containing the available transfer targets.

```javascript
{
    type: "zcc-target-list-response",
    data: {
        status: true,
        requestId: REQUEST_ID,
        query: QUERY_STRING,
        keyword: KEYWORD_STRING,
        transferTargetList: [
            {
                isZcc: true, // or false
                ZccType: "user", // or "queue" or "flow"
                id: TARGET_ID,
                name: TARGET_NAME,
                email: TARGET_EMAIL,
                description: TARGET_DESCRIPTION,
                userCount: USER_COUNT,
                channelTypes: [CHANNEL_TYPE_NUMBERS],
                operatingHoursAvailable: true, // or false
                enableAllowSelectSkillForTransfer: true, // or false
            },
        ],
    },
}
```

### zcc-transfer-engagement

Send this event to start a voice transfer.

`transferType` must be `direct` or `warm`.

`destination` is required and may be a phone number string or an object with transfer target details.

```javascript
{
    type: "zcc-transfer-engagement",
    data: {
        engagementId: ENGAGEMENT_ID,
        channelType: "voice",
        requestId: REQUEST_ID,
        transferType: "warm", // or "direct"
        destination: DESTINATION_PHONE, // or object with {value, name, isNumber, isZcc, ZccType, id}
    },
}
```

### zcc-transfer-engagement-response

Smart Embed responds with this event after the transfer operation.

On success, `status` is `true`.

On failure, `status` is `false` with `errorCode` and `error` fields.

```javascript
{
    type: "zcc-transfer-engagement-response",
    data: {
        status: true, // or false on failure
        requestId: REQUEST_ID,
        engagementId: ENGAGEMENT_ID,
        channelType: "voice",
        taskSid: TASK_SID,
        conferenceId: CONFERENCE_ID,
        transferType: "warm", // or "direct"
        timestamp: TIMESTAMP_MS,
        holdState: true, // or false
        consultState: "completed", // or "initiated", "ringing", "answered", "bridged"
        destinationSummary: {
            kind: "user", // or "queue", "flow", "pstn", "unknown"
            id: TARGET_ID,
            name: TARGET_NAME,
            queueId: QUEUE_ID,
            queueName: QUEUE_NAME,
            value: DESTINATION_VALUE,
        },
        transferId: TRANSFER_ID, // if provided by backend
        inviter_leg_channel_id: CHANNEL_ID, // if provided by backend
        errorCode: ERROR_CODE, // on failure only
        error: ERROR_MESSAGE, // on failure only
    },
}
```

### zcc-add-call

Send this event to add a second leg (consult or conference) on voice.

`destination` is required and may be a phone number string or an object with transfer target details.

`transferType` defaults to `warm` if omitted.

```javascript
{
    type: "zcc-add-call",
    data: {
        engagementId: ENGAGEMENT_ID,
        channelType: "voice",
        requestId: REQUEST_ID,
        transferType: "warm", // optional; "direct" | "warm"
        destination: DESTINATION_PHONE, // or object with {value, name, isNumber, isZcc, ZccType, id}
    },
}
```

### zcc-add-call-response

Smart Embed responds with this event after adding a consult or conference call leg.

On success, `consultState` reflects the progress.

On failure, `status` is `false` with `errorCode`.

```javascript
{
    type: "zcc-add-call-response",
    data: {
        status: true, // or false on failure
        requestId: REQUEST_ID,
        engagementId: ENGAGEMENT_ID,
        channelType: "voice",
        taskSid: TASK_SID,
        conferenceId: CONFERENCE_ID,
        transferType: "warm",
        timestamp: TIMESTAMP_MS,
        holdState: true, // or false
        consultState: "initiated", // or "ringing", "bridged"
        destinationSummary: {
            kind: "user", // or "queue", "flow", "pstn", "unknown"
            id: TARGET_ID,
            name: TARGET_NAME,
        },
        errorCode: ERROR_CODE, // on failure only
        error: ERROR_MESSAGE, // on failure only
    },
}
```

### zcc-cancel-consult

Send this event to cancel an in-progress consult or warm-transfer leg on voice.

Works for both warm transfer and conference flows.

You may supply the optional `consultParticipantId` and `reason`.

```javascript
{
    type: "zcc-cancel-consult",
    data: {
        engagementId: ENGAGEMENT_ID,
        channelType: "voice",
        requestId: REQUEST_ID,
        consultParticipantId: PARTICIPANT_ID, // optional
        reason: REASON, // optional
    },
}
```

### zcc-cancel-consult-response

Smart Embed responds with this event after canceling the consult.

On success, `consultState` is `cancelled`.

On failure, `status` is `false` with `errorCode`.

```javascript
{
    type: "zcc-cancel-consult-response",
    data: {
        status: true, // or false on failure
        requestId: REQUEST_ID,
        engagementId: ENGAGEMENT_ID,
        channelType: "voice",
        taskSid: TASK_SID,
        conferenceId: CONFERENCE_ID,
        transferType: "warm",
        timestamp: TIMESTAMP_MS,
        holdState: true, // or false
        consultState: "cancelled",
        destinationSummary: {
            kind: "user",
            id: TARGET_ID,
            name: TARGET_NAME,
        },
        errorCode: ERROR_CODE, // on failure only
        error: ERROR_MESSAGE, // on failure only
    },
}
```

### zcc-complete-transfer

Send this event to complete a warm transfer by connecting the consult leg and dropping the agent.

Voice only.

The consult leg is tracked internally, so no participant ID is required.

```javascript
{
    type: "zcc-complete-transfer",
    data: {
        engagementId: ENGAGEMENT_ID,
        channelType: "voice",
        requestId: REQUEST_ID,
    },
}
```

### zcc-complete-transfer-response

Smart Embed responds with this event after completing the warm transfer.

On success, `consultState` is `completed`.

On failure, `status` is `false` with `errorCode`.

```javascript
{
    type: "zcc-complete-transfer-response",
    data: {
        status: true, // or false on failure
        requestId: REQUEST_ID,
        engagementId: ENGAGEMENT_ID,
        channelType: "voice",
        taskSid: TASK_SID,
        conferenceId: CONFERENCE_ID,
        transferType: "warm",
        timestamp: TIMESTAMP_MS,
        holdState: true, // or false
        consultState: "completed",
        destinationSummary: {
            kind: "user",
            id: TARGET_ID,
            name: TARGET_NAME,
        },
        transferId: TRANSFER_ID, // if provided by backend
        inviter_leg_channel_id: CHANNEL_ID, // if provided by backend
        errorCode: ERROR_CODE, // on failure only
        error: ERROR_MESSAGE, // on failure only
    },
}
```

### zcc-merge-consult

Send this event to merge the active conference consult leg so all parties are bridged.

Voice only.

The consult leg is tracked internally, so no participant ID is required.

```javascript
{
    type: "zcc-merge-consult",
    data: {
        engagementId: ENGAGEMENT_ID,
        channelType: "voice",
        requestId: REQUEST_ID,
    },
}
```

### zcc-merge-consult-response

Smart Embed responds with this event after merging the consult into the conference.

On success, `consultState` is `merged`.

On failure, `status` is `false` with `errorCode`.

```javascript
{
    type: "zcc-merge-consult-response",
    data: {
        status: true, // or false on failure
        requestId: REQUEST_ID,
        engagementId: ENGAGEMENT_ID,
        channelType: "voice",
        taskSid: TASK_SID,
        conferenceId: CONFERENCE_ID,
        transferType: "warm",
        timestamp: TIMESTAMP_MS,
        holdState: true, // or false
        consultState: "merged",
        destinationSummary: {
            kind: "user",
            id: TARGET_ID,
            name: TARGET_NAME,
        },
        errorCode: ERROR_CODE, // on failure only
        error: ERROR_MESSAGE, // on failure only
    },
}
```

## Agent Status

These events track and control agent status changes, including online, ready, and custom status codes.

### zcc-agent-status-notification

This event fires when there's an update in the agent status.

`statusCode` values:

-   0 - Offline
-   1 - Ready
-   2 - Not Ready
-   3 - Occupied

When the new status refers to a subreason, `statusCode` indicates that subreason's status code, and `parentStatusCode` indicates the parent status.

```javascript
{
    type: "zcc-agent-status-notification",
    data: {
        "statusCode": STATUS_CODE,
        "status": STATUS,
        "parentStatusCode": PARENT_STATUS_CODE, // [If applicable]
        "subReason": SUB_REASON, // [If applicable]
    },
};
```

### zcc-agent-status-get-request

Send this event to retrieve the agent's current status from Smart Embed on demand.

Smart Embed responds with `zcc-agent-status-notification`.

```javascript
{
    type: "zcc-agent-status-get-request",
};
```

### zcc-agent-status-set-request

Send this event to set the agent's status.

The status code must be a valid predefined or preconfigured Contact Center status code.

Smart Embed synchronizes and updates the agent status after receiving this event.

```javascript
{
    type: "zcc-agent-status-set-request",
    data: {
         id: STATUS_CODE,
    },
};
```

## Disposition Codes

These events retrieve disposition codes for categorizing completed engagements during wrap-up.

### zcc-get-disposition-codes

Send this event to request wrap-up or disposition codes for an engagement or queue.

Required fields:

-   `requestId`
-   At least one of `engagementId` or `queueId`

Optional fields:

-   `channelType` (validated against supported channel types)

Smart Embed responds with `zcc-get-disposition-codes-response`.

```javascript
{
    type: "zcc-get-disposition-codes",
    data: {
        requestId: REQUEST_ID,
        engagementId: ENGAGEMENT_ID,
        channelType: "voice", // optional
        queueId: QUEUE_ID, // optional
    },
}
```

### zcc-get-disposition-codes-response

Smart Embed responds with this event after a `zcc-get-disposition-codes` request.

`codes` is a list (possibly nested) of disposition objects with fields such as `id`, `name`, `description`, `dispositionType`, and optional `subDispositionList`.

```javascript
{
    type: "zcc-get-disposition-codes-response",
    data: {
        requestId: REQUEST_ID,
        codes: [ /* disposition tree */ ],
    },
}
```

## Custom Variables

These events retrieve global custom variable data configured in Contact Center.

### zcc-get-variables

Send this event to request custom variable data from Contact Center.

```javascript
{
    type: "zcc-get-variables",
    data: {
        engagementId: ENGAGEMENT_ID,
    },
}
```

### zcc-get-variables-response

Smart Embed responds with this event after a `zcc-get-variables` request.

Returns a list of custom variables. Only custom global variables configured to display in the desktop client are included.

```javascript
{
    type: "zcc-get-variables-response",
    data: {
        engagementId: "GrHVH9d9fdlfjlfs8fHrg",
        variables: [
            {
                globalVariableId: VARIABLE_ID,
                globalVariableName: VARIABLE_NAME,
                globalVariableDisplayName: VARIABLE_DISPLAY_NAME,
                globalVariableType: "Global_Variable",
                dataType: DATA_TYPE,
                value: VARIABLE_VALUE,
                screen: "Engagement",
            },
        ],
    },
}
```

## Notes

This event captures notes added by agents during engagements.

### zcc-add-note

This event fires when an agent adds a note in Smart Embed, or when logging miscellaneous information like webchat or SMS transcripts.

```javascript
{
    type: "zcc-add-note",
    data: {
        comment: "<Note contents>",
    },
}
```