Class PhoneEndpoints

Hierarchy

  • WebEndpoints
    • PhoneEndpoints

Constructors

constructor

Properties

accounts alerts audioLibrary autoReceptionists billingAccount blockedList callHandling callLogs callQueues carrierReseller commonAreas dashboard deviceLineKeys dialByNameDirectory emergencyAddresses emergencyServiceLocations externalContacts firmwareUpdateRules groupCallPickup groups inboundBlockedList iVR lineKeys monitoringGroups outboundCalling phoneDevices phoneNumbers phonePlans phoneRoles privateDirectory providerExchange provisionTemplates recordings reports routingRules settings settingTemplates sharedLineAppearance sharedLineGroup sites sMS sMSCampaign users voicemails zoomRooms

Constructors

constructor

Properties

Readonlyaccounts

accounts: {
    addPhoneNumbersForAccountsCustomizedOutboundCallerID: (
        _: {
            body?: AccountsAddPhoneNumbersForAccountsCustomizedOutboundCallerIDRequestBody;
        },
    ) => Promise<BaseResponse<unknown>>;
    deletePhoneNumbersForAccountsCustomizedOutboundCallerID: (
        _: {
            query?: AccountsDeletePhoneNumbersForAccountsCustomizedOutboundCallerIDQueryParams;
        },
    ) => Promise<BaseResponse<unknown>>;
    listAccountsCustomizedOutboundCallerIDPhoneNumbers: (
        _: {
            query?: AccountsListAccountsCustomizedOutboundCallerIDPhoneNumbersQueryParams;
        },
    ) => Promise<
        BaseResponse<
            AccountsListAccountsCustomizedOutboundCallerIDPhoneNumbersResponse,
        >,
    >;
    listAccountsZoomPhoneSettings: (
        _: { query?: AccountsListAccountsZoomPhoneSettingsQueryParams },
    ) => Promise<BaseResponse<AccountsListAccountsZoomPhoneSettingsResponse>>;
}

Readonlyalerts

alerts: {
    addAlertSetting: (
        _: { body: AlertsAddAlertSettingRequestBody },
    ) => Promise<BaseResponse<AlertsAddAlertSettingResponse>>;
    deleteAlertSetting: (
        _: { path: AlertsDeleteAlertSettingPathParams },
    ) => Promise<BaseResponse<unknown>>;
    getAlertSettingDetails: (
        _: { path: AlertsGetAlertSettingDetailsPathParams },
    ) => Promise<BaseResponse<AlertsGetAlertSettingDetailsResponse>>;
    listAlertSettingsWithPagingQuery: (
        _: { query?: AlertsListAlertSettingsWithPagingQueryQueryParams },
    ) => Promise<BaseResponse<AlertsListAlertSettingsWithPagingQueryResponse>>;
    updateAlertSetting: (
        _: {
            body?: AlertsUpdateAlertSettingRequestBody;
            path: AlertsUpdateAlertSettingPathParams;
        },
    ) => Promise<BaseResponse<unknown>>;
}

ReadonlyaudioLibrary

audioLibrary: {
    addAudioItemForTextToSpeechConversion: (
        _: {
            body?: AudioLibraryAddAudioItemForTextToSpeechConversionRequestBody;
            path: AudioLibraryAddAudioItemForTextToSpeechConversionPathParams;
        },
    ) => Promise<
        BaseResponse<AudioLibraryAddAudioItemForTextToSpeechConversionResponse>,
    >;
    addAudioItems: (
        _: {
            body?: AudioLibraryAddAudioItemsRequestBody;
            path: AudioLibraryAddAudioItemsPathParams;
        },
    ) => Promise<BaseResponse<AudioLibraryAddAudioItemsResponse>>;
    deleteAudioItem: (
        _: { path: AudioLibraryDeleteAudioItemPathParams },
    ) => Promise<BaseResponse<unknown>>;
    getAudioItem: (
        _: { path: AudioLibraryGetAudioItemPathParams },
    ) => Promise<BaseResponse<AudioLibraryGetAudioItemResponse>>;
    listAudioItems: (
        _: { path: AudioLibraryListAudioItemsPathParams },
    ) => Promise<BaseResponse<AudioLibraryListAudioItemsResponse>>;
    updateAudioItem: (
        _: {
            body: AudioLibraryUpdateAudioItemRequestBody;
            path: AudioLibraryUpdateAudioItemPathParams;
        },
    ) => Promise<BaseResponse<unknown>>;
}

ReadonlyautoReceptionists

autoReceptionists: {
    addAutoReceptionist: (
        _: { body: AutoReceptionistsAddAutoReceptionistRequestBody },
    ) => Promise<BaseResponse<AutoReceptionistsAddAutoReceptionistResponse>>;
    addPolicySubsetting: (
        _: {
            body?: AutoReceptionistsAddPolicySubsettingRequestBody;
            path: AutoReceptionistsAddPolicySubsettingPathParams;
        },
    ) => Promise<BaseResponse<AutoReceptionistsAddPolicySubsettingResponse>>;
    assignPhoneNumbers: (
        _: {
            body?: AutoReceptionistsAssignPhoneNumbersRequestBody;
            path: AutoReceptionistsAssignPhoneNumbersPathParams;
        },
    ) => Promise<BaseResponse<unknown>>;
    deleteNonPrimaryAutoReceptionist: (
        _: {
            path: AutoReceptionistsDeleteNonPrimaryAutoReceptionistPathParams;
        },
    ) => Promise<BaseResponse<unknown>>;
    deletePolicySubsetting: (
        _: {
            path: AutoReceptionistsDeletePolicySubsettingPathParams;
            query: AutoReceptionistsDeletePolicySubsettingQueryParams;
        },
    ) => Promise<BaseResponse<unknown>>;
    getAutoReceptionist: (
        _: { path: AutoReceptionistsGetAutoReceptionistPathParams },
    ) => Promise<BaseResponse<AutoReceptionistsGetAutoReceptionistResponse>>;
    getAutoReceptionistPolicy: (
        _: { path: AutoReceptionistsGetAutoReceptionistPolicyPathParams },
    ) => Promise<
        BaseResponse<AutoReceptionistsGetAutoReceptionistPolicyResponse>,
    >;
    listAutoReceptionists: (
        _: { query?: AutoReceptionistsListAutoReceptionistsQueryParams },
    ) => Promise<BaseResponse<AutoReceptionistsListAutoReceptionistsResponse>>;
    unassignAllPhoneNumbers: (
        _: { path: AutoReceptionistsUnassignAllPhoneNumbersPathParams },
    ) => Promise<BaseResponse<unknown>>;
    unassignPhoneNumber: (
        _: { path: AutoReceptionistsUnassignPhoneNumberPathParams },
    ) => Promise<BaseResponse<unknown>>;
    updateAutoReceptionist: (
        _: {
            body?: AutoReceptionistsUpdateAutoReceptionistRequestBody;
            path: AutoReceptionistsUpdateAutoReceptionistPathParams;
        },
    ) => Promise<BaseResponse<unknown>>;
    updateAutoReceptionistPolicy: (
        _: {
            body?: AutoReceptionistsUpdateAutoReceptionistPolicyRequestBody;
            path: AutoReceptionistsUpdateAutoReceptionistPolicyPathParams;
        },
    ) => Promise<BaseResponse<unknown>>;
    updatePolicySubsetting: (
        _: {
            body?: AutoReceptionistsUpdatePolicySubsettingRequestBody;
            path: AutoReceptionistsUpdatePolicySubsettingPathParams;
        },
    ) => Promise<BaseResponse<unknown>>;
}

ReadonlybillingAccount

billingAccount: {
    getBillingAccountDetails: (
        _: { path: BillingAccountGetBillingAccountDetailsPathParams },
    ) => Promise<BaseResponse<BillingAccountGetBillingAccountDetailsResponse>>;
    listBillingAccounts: (
        _: { query?: BillingAccountListBillingAccountsQueryParams },
    ) => Promise<BaseResponse<BillingAccountListBillingAccountsResponse>>;
}

ReadonlyblockedList

blockedList: {
    createBlockedList: (
        _: { body?: BlockedListCreateBlockedListRequestBody },
    ) => Promise<BaseResponse<BlockedListCreateBlockedListResponse>>;
    deleteBlockedList: (
        _: { path: BlockedListDeleteBlockedListPathParams },
    ) => Promise<BaseResponse<unknown>>;
    getBlockedListDetails: (
        _: { path: BlockedListGetBlockedListDetailsPathParams },
    ) => Promise<BaseResponse<BlockedListGetBlockedListDetailsResponse>>;
    listBlockedLists: (
        _: { query?: BlockedListListBlockedListsQueryParams },
    ) => Promise<BaseResponse<BlockedListListBlockedListsResponse>>;
    updateBlockedList: (
        _: {
            body?: BlockedListUpdateBlockedListRequestBody;
            path: BlockedListUpdateBlockedListPathParams;
        },
    ) => Promise<BaseResponse<unknown>>;
}

ReadonlycallHandling

callHandling: {
    addCallHandlingSetting: (
        _:
            | {
                body?: {
                    settings?: {
                        description?: string;
                        holiday_id?: string;
                        phone_number?: string;
                    };
                    sub_setting_type?: string;
                };
                path: CallHandlingAddCallHandlingSettingPathParams;
            }
            | {
                body?: {
                    settings?: { from?: string; name?: string; to?: string };
                    sub_setting_type?: string;
                };
                path: CallHandlingAddCallHandlingSettingPathParams;
            },
    ) => Promise<BaseResponse<CallHandlingAddCallHandlingSettingResponse>>;
    deleteCallHandlingSetting: (
        _: {
            path: CallHandlingDeleteCallHandlingSettingPathParams;
            query?: CallHandlingDeleteCallHandlingSettingQueryParams;
        },
    ) => Promise<BaseResponse<unknown>>;
    getCallHandlingSettings: (
        _: { path: CallHandlingGetCallHandlingSettingsPathParams },
    ) => Promise<BaseResponse<CallHandlingGetCallHandlingSettingsResponse>>;
    updateCallHandlingSetting: (
        _:
            | {
                body?: {
                    settings?: {
                        call_forwarding_settings?: {
                            description?: string;
                            enable?: boolean;
                            external_contact?: { external_contact_id?: string };
                            id?: string;
                            phone_number?: string;
                        }[];
                        require_press_1_before_connecting?: boolean;
                    };
                    sub_setting_type?: string;
                };
                path: CallHandlingUpdateCallHandlingSettingPathParams;
            }
            | {
                body?: {
                    settings?: {
                        from?: string;
                        holiday_id?: string;
                        name?: string;
                        to?: string;
                    };
                    sub_setting_type?: string;
                };
                path: CallHandlingUpdateCallHandlingSettingPathParams;
            }
            | {
                body?: {
                    settings?: {
                        allow_members_to_reset?: boolean;
                        custom_hours_settings?: {
                            from?: string;
                            to?: string;
                            type?: number;
                            weekday?: number;
                        }[];
                        type?: number;
                    };
                    sub_setting_type?: string;
                };
                path: CallHandlingUpdateCallHandlingSettingPathParams;
            }
            | {
                body?: {
                    settings?: {
                        allow_callers_check_voicemail?: boolean;
                        allow_members_to_reset?: boolean;
                        audio_while_connecting_id?: string;
                        busy_description?: string;
                        busy_forward_to_extension_id?: string;
                        busy_on_another_call_action?: number;
                        busy_phone_number?: string;
                        busy_play_callee_voicemail_greeting?: boolean;
                        busy_require_press_1_before_connecting?: boolean;
                        call_distribution?: {
                            handle_multiple_calls?: boolean;
                            ring_duration?: number;
                            ring_mode?: string;
                            skip_offline_device_phone_number?: boolean;
                        };
                        call_not_answer_action?: number;
                        connect_to_operator?: boolean;
                        description?: string;
                        forward_to_extension_id?: string;
                        forward_to_partner_contact_center_id?: string;
                        forward_to_teams_id?: string;
                        forward_to_zcc_phone_number?: string;
                        greeting_prompt_id?: string;
                        max_call_in_queue?: number;
                        max_wait_time?: number;
                        message_greeting_id?: string;
                        music_on_hold_id?: string;
                        operator_extension_id?: string;
                        overflow_play_callee_voicemail_greeting?: boolean;
                        phone_number?: string;
                        play_callee_voicemail_greeting?: boolean;
                        receive_call?: boolean;
                        ring_mode?: string;
                        un_answered_require_press_1_before_connecting?: boolean;
                        voicemail_greeting_id?: string;
                        voicemail_leaving_instruction_id?: string;
                        wrap_up_time?: number;
                    };
                    sub_setting_type?: string;
                };
                path: CallHandlingUpdateCallHandlingSettingPathParams;
            },
    ) => Promise<BaseResponse<unknown>>;
}

ReadonlycallLogs

callLogs: {
    addClientCodeToCallHistory: (
        _: {
            body: CallLogsAddClientCodeToCallHistoryRequestBody;
            path: CallLogsAddClientCodeToCallHistoryPathParams;
        },
    ) => Promise<BaseResponse<unknown>>;
    addClientCodeToCallLog: (
        _: {
            body: CallLogsAddClientCodeToCallLogRequestBody;
            path: CallLogsAddClientCodeToCallLogPathParams;
        },
    ) => Promise<BaseResponse<unknown>>;
    deleteUsersCallHistory: (
        _: { path: CallLogsDeleteUsersCallHistoryPathParams },
    ) => Promise<BaseResponse<unknown>>;
    deleteUsersCallLog: (
        _: { path: CallLogsDeleteUsersCallLogPathParams },
    ) => Promise<BaseResponse<unknown>>;
    getAccountsCallHistory: (
        _: { query?: CallLogsGetAccountsCallHistoryQueryParams },
    ) => Promise<BaseResponse<CallLogsGetAccountsCallHistoryResponse>>;
    getAccountsCallLogs: (
        _: { query?: CallLogsGetAccountsCallLogsQueryParams },
    ) => Promise<BaseResponse<CallLogsGetAccountsCallLogsResponse>>;
    getCallLogDetails: (
        _: { path: CallLogsGetCallLogDetailsPathParams },
    ) => Promise<BaseResponse<CallLogsGetCallLogDetailsResponse>>;
    getCallPath: (
        _: { path: CallLogsGetCallPathPathParams },
    ) => Promise<BaseResponse<CallLogsGetCallPathResponse>>;
    getUsersCallHistory: (
        _: {
            path: CallLogsGetUsersCallHistoryPathParams;
            query?: CallLogsGetUsersCallHistoryQueryParams;
        },
    ) => Promise<BaseResponse<CallLogsGetUsersCallHistoryResponse>>;
    getUsersCallLogs: (
        _: {
            path: CallLogsGetUsersCallLogsPathParams;
            query?: CallLogsGetUsersCallLogsQueryParams;
        },
    ) => Promise<BaseResponse<CallLogsGetUsersCallLogsResponse>>;
    syncUsersCallHistory: (
        _: {
            path: CallLogsSyncUsersCallHistoryPathParams;
            query?: CallLogsSyncUsersCallHistoryQueryParams;
        },
    ) => Promise<BaseResponse<CallLogsSyncUsersCallHistoryResponse>>;
    syncUsersCallLogs: (
        _: {
            path: CallLogsSyncUsersCallLogsPathParams;
            query?: CallLogsSyncUsersCallLogsQueryParams;
        },
    ) => Promise<BaseResponse<CallLogsSyncUsersCallLogsResponse>>;
}

ReadonlycallQueues

callQueues: {
    addMembersToCallQueue: (
        _: {
            body?: CallQueuesAddMembersToCallQueueRequestBody;
            path: CallQueuesAddMembersToCallQueuePathParams;
        },
    ) => Promise<BaseResponse<unknown>>;
    addPolicySettingToCallQueue: (
        _: {
            body?: CallQueuesAddPolicySettingToCallQueueRequestBody;
            path: CallQueuesAddPolicySettingToCallQueuePathParams;
        },
    ) => Promise<BaseResponse<CallQueuesAddPolicySettingToCallQueueResponse>>;
    assignNumbersToCallQueue: (
        _: {
            body?: CallQueuesAssignNumbersToCallQueueRequestBody;
            path: CallQueuesAssignNumbersToCallQueuePathParams;
        },
    ) => Promise<BaseResponse<unknown>>;
    createCallQueue: (
        _: { body: CallQueuesCreateCallQueueRequestBody },
    ) => Promise<BaseResponse<CallQueuesCreateCallQueueResponse>>;
    deleteCallQueue: (
        _: { path: CallQueuesDeleteCallQueuePathParams },
    ) => Promise<BaseResponse<unknown>>;
    deleteCQPolicySetting: (
        _: {
            path: CallQueuesDeleteCQPolicySettingPathParams;
            query: CallQueuesDeleteCQPolicySettingQueryParams;
        },
    ) => Promise<BaseResponse<unknown>>;
    getCallQueueDetails: (
        _: { path: CallQueuesGetCallQueueDetailsPathParams },
    ) => Promise<BaseResponse<CallQueuesGetCallQueueDetailsResponse>>;
    getCallQueueRecordings: (
        _: {
            path: CallQueuesGetCallQueueRecordingsPathParams;
            query?: CallQueuesGetCallQueueRecordingsQueryParams;
        },
    ) => Promise<BaseResponse<CallQueuesGetCallQueueRecordingsResponse>>;
    listCallQueueMembers: (
        _: { path: CallQueuesListCallQueueMembersPathParams },
    ) => Promise<BaseResponse<CallQueuesListCallQueueMembersResponse>>;
    listCallQueues: (
        _: { query?: CallQueuesListCallQueuesQueryParams },
    ) => Promise<BaseResponse<CallQueuesListCallQueuesResponse>>;
    unassignAllMembers: (
        _: { path: CallQueuesUnassignAllMembersPathParams },
    ) => Promise<BaseResponse<unknown>>;
    unassignAllPhoneNumbers: (
        _: { path: CallQueuesUnassignAllPhoneNumbersPathParams },
    ) => Promise<BaseResponse<unknown>>;
    unassignMember: (
        _: { path: CallQueuesUnassignMemberPathParams },
    ) => Promise<BaseResponse<unknown>>;
    unassignPhoneNumber: (
        _: { path: CallQueuesUnassignPhoneNumberPathParams },
    ) => Promise<BaseResponse<unknown>>;
    updateCallQueueDetails: (
        _: {
            body?: CallQueuesUpdateCallQueueDetailsRequestBody;
            path: CallQueuesUpdateCallQueueDetailsPathParams;
        },
    ) => Promise<BaseResponse<unknown>>;
    updateCallQueuesPolicySubsetting: (
        _: {
            body?: CallQueuesUpdateCallQueuesPolicySubsettingRequestBody;
            path: CallQueuesUpdateCallQueuesPolicySubsettingPathParams;
        },
    ) => Promise<BaseResponse<unknown>>;
}

ReadonlycarrierReseller

carrierReseller: {
    activatePhoneNumbers: (
        _: { body: CarrierResellerActivatePhoneNumbersRequestBody },
    ) => Promise<BaseResponse<unknown>>;
    createPhoneNumbers: (
        _: { body: CarrierResellerCreatePhoneNumbersRequestBody },
    ) => Promise<BaseResponse<unknown>>;
    deletePhoneNumber: (
        _: { path: CarrierResellerDeletePhoneNumberPathParams },
    ) => Promise<BaseResponse<unknown>>;
    listPhoneNumbers: (
        _: { query?: CarrierResellerListPhoneNumbersQueryParams },
    ) => Promise<BaseResponse<CarrierResellerListPhoneNumbersResponse>>;
}

ReadonlycommonAreas

commonAreas: {
    addCommonArea: (
        _: { body: CommonAreasAddCommonAreaRequestBody },
    ) => Promise<BaseResponse<CommonAreasAddCommonAreaResponse>>;
    addCommonAreaSettings: (
        _: {
            body?: CommonAreasAddCommonAreaSettingsRequestBody;
            path: CommonAreasAddCommonAreaSettingsPathParams;
        },
    ) => Promise<BaseResponse<CommonAreasAddCommonAreaSettingsResponse>>;
    applyTemplateToCommonAreas: (
        _: {
            body?: CommonAreasApplyTemplateToCommonAreasRequestBody;
            path: CommonAreasApplyTemplateToCommonAreasPathParams;
        },
    ) => Promise<BaseResponse<unknown>>;
    assignCallingPlansToCommonArea: (
        _: {
            body: CommonAreasAssignCallingPlansToCommonAreaRequestBody;
            path: CommonAreasAssignCallingPlansToCommonAreaPathParams;
        },
    ) => Promise<
        BaseResponse<CommonAreasAssignCallingPlansToCommonAreaResponse>,
    >;
    assignPhoneNumbersToCommonArea: (
        _: {
            body: CommonAreasAssignPhoneNumbersToCommonAreaRequestBody;
            path: CommonAreasAssignPhoneNumbersToCommonAreaPathParams;
        },
    ) => Promise<
        BaseResponse<CommonAreasAssignPhoneNumbersToCommonAreaResponse>,
    >;
    deleteCommonArea: (
        _: { path: CommonAreasDeleteCommonAreaPathParams },
    ) => Promise<BaseResponse<unknown>>;
    deleteCommonAreaSetting: (
        _: {
            path: CommonAreasDeleteCommonAreaSettingPathParams;
            query: CommonAreasDeleteCommonAreaSettingQueryParams;
        },
    ) => Promise<BaseResponse<unknown>>;
    getCommonAreaDetails: (
        _: { path: CommonAreasGetCommonAreaDetailsPathParams },
    ) => Promise<BaseResponse<CommonAreasGetCommonAreaDetailsResponse>>;
    getCommonAreaSettings: (
        _: { path: CommonAreasGetCommonAreaSettingsPathParams },
    ) => Promise<BaseResponse<CommonAreasGetCommonAreaSettingsResponse>>;
    listActivationCodes: (
        _: { query?: CommonAreasListActivationCodesQueryParams },
    ) => Promise<BaseResponse<CommonAreasListActivationCodesResponse>>;
    listCommonAreas: (
        _: { query?: CommonAreasListCommonAreasQueryParams },
    ) => Promise<BaseResponse<CommonAreasListCommonAreasResponse>>;
    unassignCallingPlanFromCommonArea: (
        _: {
            path: CommonAreasUnassignCallingPlanFromCommonAreaPathParams;
            query?: CommonAreasUnassignCallingPlanFromCommonAreaQueryParams;
        },
    ) => Promise<BaseResponse<unknown>>;
    unassignPhoneNumbersFromCommonArea: (
        _: { path: CommonAreasUnassignPhoneNumbersFromCommonAreaPathParams },
    ) => Promise<BaseResponse<unknown>>;
    updateCommonArea: (
        _: {
            body?: CommonAreasUpdateCommonAreaRequestBody;
            path: CommonAreasUpdateCommonAreaPathParams;
        },
    ) => Promise<BaseResponse<unknown>>;
    updateCommonAreaPinCode: (
        _: {
            body: CommonAreasUpdateCommonAreaPinCodeRequestBody;
            path: CommonAreasUpdateCommonAreaPinCodePathParams;
        },
    ) => Promise<BaseResponse<unknown>>;
    updateCommonAreaSettings: (
        _: {
            body?: CommonAreasUpdateCommonAreaSettingsRequestBody;
            path: CommonAreasUpdateCommonAreaSettingsPathParams;
        },
    ) => Promise<BaseResponse<unknown>>;
}

Readonlydashboard

dashboard: {
    getCallDetailsFromCallLog: (
        _: { path: DashboardGetCallDetailsFromCallLogPathParams },
    ) => Promise<BaseResponse<DashboardGetCallDetailsFromCallLogResponse>>;
    getCallQoS: (
        _: { path: DashboardGetCallQoSPathParams },
    ) => Promise<BaseResponse<DashboardGetCallQoSResponse>>;
    listCallLogs: (
        _: { query?: DashboardListCallLogsQueryParams },
    ) => Promise<BaseResponse<DashboardListCallLogsResponse>>;
    listPastCallMetrics: (
        _: { query?: DashboardListPastCallMetricsQueryParams },
    ) => Promise<BaseResponse<DashboardListPastCallMetricsResponse>>;
    listTrackedLocations: (
        _: { query?: DashboardListTrackedLocationsQueryParams },
    ) => Promise<BaseResponse<DashboardListTrackedLocationsResponse>>;
}

ReadonlydeviceLineKeys

deviceLineKeys: {
    batchUpdateDeviceLineKeyPosition: (
        _: {
            body?: DeviceLineKeysBatchUpdateDeviceLineKeyPositionRequestBody;
            path: DeviceLineKeysBatchUpdateDeviceLineKeyPositionPathParams;
        },
    ) => Promise<BaseResponse<unknown>>;
    getDeviceLineKeysInformation: (
        _: { path: DeviceLineKeysGetDeviceLineKeysInformationPathParams },
    ) => Promise<
        BaseResponse<DeviceLineKeysGetDeviceLineKeysInformationResponse>,
    >;
}

ReadonlydialByNameDirectory

dialByNameDirectory: {
    addUsersToDirectory: (
        _: { body: DialByNameDirectoryAddUsersToDirectoryRequestBody },
    ) => Promise<BaseResponse<unknown>>;
    addUsersToDirectoryOfSite: (
        _: {
            body?: DialByNameDirectoryAddUsersToDirectoryOfSiteRequestBody;
            path: DialByNameDirectoryAddUsersToDirectoryOfSitePathParams;
        },
    ) => Promise<BaseResponse<unknown>>;
    deleteUsersFromDirectory: (
        _: { query: DialByNameDirectoryDeleteUsersFromDirectoryQueryParams },
    ) => Promise<BaseResponse<unknown>>;
    deleteUsersFromDirectoryOfSite: (
        _: {
            path: DialByNameDirectoryDeleteUsersFromDirectoryOfSitePathParams;
            query?: DialByNameDirectoryDeleteUsersFromDirectoryOfSiteQueryParams;
        },
    ) => Promise<BaseResponse<unknown>>;
    listUsersInDirectory: (
        _: { query: DialByNameDirectoryListUsersInDirectoryQueryParams },
    ) => Promise<BaseResponse<DialByNameDirectoryListUsersInDirectoryResponse>>;
    listUsersInDirectoryBySite: (
        _: {
            path: DialByNameDirectoryListUsersInDirectoryBySitePathParams;
            query?: DialByNameDirectoryListUsersInDirectoryBySiteQueryParams;
        },
    ) => Promise<
        BaseResponse<DialByNameDirectoryListUsersInDirectoryBySiteResponse>,
    >;
}

ReadonlyemergencyAddresses

emergencyAddresses: {
    addEmergencyAddress: (
        _: { body: EmergencyAddressesAddEmergencyAddressRequestBody },
    ) => Promise<BaseResponse<EmergencyAddressesAddEmergencyAddressResponse>>;
    deleteEmergencyAddress: (
        _: { path: EmergencyAddressesDeleteEmergencyAddressPathParams },
    ) => Promise<BaseResponse<unknown>>;
    getEmergencyAddressDetails: (
        _: { path: EmergencyAddressesGetEmergencyAddressDetailsPathParams },
    ) => Promise<
        BaseResponse<EmergencyAddressesGetEmergencyAddressDetailsResponse>,
    >;
    listEmergencyAddresses: (
        _: { query?: EmergencyAddressesListEmergencyAddressesQueryParams },
    ) => Promise<
        BaseResponse<EmergencyAddressesListEmergencyAddressesResponse>,
    >;
    updateEmergencyAddress: (
        _: {
            body?: EmergencyAddressesUpdateEmergencyAddressRequestBody;
            path: EmergencyAddressesUpdateEmergencyAddressPathParams;
        },
    ) => Promise<
        BaseResponse<EmergencyAddressesUpdateEmergencyAddressResponse>,
    >;
}

ReadonlyemergencyServiceLocations

emergencyServiceLocations: {
    addEmergencyServiceLocation: (
        _: {
            body: EmergencyServiceLocationsAddEmergencyServiceLocationRequestBody;
        },
    ) => Promise<
        BaseResponse<
            EmergencyServiceLocationsAddEmergencyServiceLocationResponse,
        >,
    >;
    batchAddEmergencyServiceLocations: (
        _: {
            body: EmergencyServiceLocationsBatchAddEmergencyServiceLocationsRequestBody;
        },
    ) => Promise<
        BaseResponse<
            EmergencyServiceLocationsBatchAddEmergencyServiceLocationsResponse,
        >,
    >;
    deleteEmergencyLocation: (
        _: { path: EmergencyServiceLocationsDeleteEmergencyLocationPathParams },
    ) => Promise<BaseResponse<unknown>>;
    getEmergencyServiceLocationDetails: (
        _: {
            path: EmergencyServiceLocationsGetEmergencyServiceLocationDetailsPathParams;
        },
    ) => Promise<
        BaseResponse<
            EmergencyServiceLocationsGetEmergencyServiceLocationDetailsResponse,
        >,
    >;
    listEmergencyServiceLocations: (
        _: {
            query?: EmergencyServiceLocationsListEmergencyServiceLocationsQueryParams;
        },
    ) => Promise<
        BaseResponse<
            EmergencyServiceLocationsListEmergencyServiceLocationsResponse,
        >,
    >;
    updateEmergencyServiceLocation: (
        _: {
            body?: EmergencyServiceLocationsUpdateEmergencyServiceLocationRequestBody;
            path: EmergencyServiceLocationsUpdateEmergencyServiceLocationPathParams;
        },
    ) => Promise<BaseResponse<unknown>>;
}

ReadonlyexternalContacts

externalContacts: {
    addExternalContact: (
        _: { body: ExternalContactsAddExternalContactRequestBody },
    ) => Promise<BaseResponse<ExternalContactsAddExternalContactResponse>>;
    deleteExternalContact: (
        _: { path: ExternalContactsDeleteExternalContactPathParams },
    ) => Promise<BaseResponse<unknown>>;
    getExternalContactDetails: (
        _: { path: ExternalContactsGetExternalContactDetailsPathParams },
    ) => Promise<
        BaseResponse<ExternalContactsGetExternalContactDetailsResponse>,
    >;
    listExternalContacts: (
        _: { query?: ExternalContactsListExternalContactsQueryParams },
    ) => Promise<BaseResponse<ExternalContactsListExternalContactsResponse>>;
    updateExternalContact: (
        _: {
            body?: ExternalContactsUpdateExternalContactRequestBody;
            path: ExternalContactsUpdateExternalContactPathParams;
        },
    ) => Promise<BaseResponse<unknown>>;
}

ReadonlyfirmwareUpdateRules

firmwareUpdateRules: {
    addFirmwareUpdateRule: (
        _: { body: FirmwareUpdateRulesAddFirmwareUpdateRuleRequestBody },
    ) => Promise<
        BaseResponse<FirmwareUpdateRulesAddFirmwareUpdateRuleResponse>,
    >;
    deleteFirmwareUpdateRule: (
        _: {
            path: FirmwareUpdateRulesDeleteFirmwareUpdateRulePathParams;
            query?: FirmwareUpdateRulesDeleteFirmwareUpdateRuleQueryParams;
        },
    ) => Promise<BaseResponse<unknown>>;
    getFirmwareUpdateRuleInformation: (
        _: {
            path: FirmwareUpdateRulesGetFirmwareUpdateRuleInformationPathParams;
        },
    ) => Promise<
        BaseResponse<
            FirmwareUpdateRulesGetFirmwareUpdateRuleInformationResponse,
        >,
    >;
    listFirmwareUpdateRules: (
        _: { query?: FirmwareUpdateRulesListFirmwareUpdateRulesQueryParams },
    ) => Promise<
        BaseResponse<FirmwareUpdateRulesListFirmwareUpdateRulesResponse>,
    >;
    listUpdatableFirmwares: (
        _: { query?: FirmwareUpdateRulesListUpdatableFirmwaresQueryParams },
    ) => Promise<
        BaseResponse<FirmwareUpdateRulesListUpdatableFirmwaresResponse>,
    >;
    updateFirmwareUpdateRule: (
        _: {
            body: FirmwareUpdateRulesUpdateFirmwareUpdateRuleRequestBody;
            path: FirmwareUpdateRulesUpdateFirmwareUpdateRulePathParams;
        },
    ) => Promise<BaseResponse<unknown>>;
}

ReadonlygroupCallPickup

groupCallPickup: {
    addGroupCallPickupObject: (
        _: { body: GroupCallPickupAddGroupCallPickupObjectRequestBody },
    ) => Promise<BaseResponse<GroupCallPickupAddGroupCallPickupObjectResponse>>;
    addMembersToCallPickupGroup: (
        _: {
            body?: GroupCallPickupAddMembersToCallPickupGroupRequestBody;
            path: GroupCallPickupAddMembersToCallPickupGroupPathParams;
        },
    ) => Promise<BaseResponse<unknown>>;
    deleteGroupCallPickupObjects: (
        _: { path: GroupCallPickupDeleteGroupCallPickupObjectsPathParams },
    ) => Promise<BaseResponse<unknown>>;
    getCallPickupGroupByID: (
        _: { path: GroupCallPickupGetCallPickupGroupByIDPathParams },
    ) => Promise<BaseResponse<GroupCallPickupGetCallPickupGroupByIDResponse>>;
    listCallPickupGroupMembers: (
        _: {
            path: GroupCallPickupListCallPickupGroupMembersPathParams;
            query?: GroupCallPickupListCallPickupGroupMembersQueryParams;
        },
    ) => Promise<
        BaseResponse<GroupCallPickupListCallPickupGroupMembersResponse>,
    >;
    listGroupCallPickupObjects: (
        _: { query?: GroupCallPickupListGroupCallPickupObjectsQueryParams },
    ) => Promise<
        BaseResponse<GroupCallPickupListGroupCallPickupObjectsResponse>,
    >;
    removeMembersFromCallPickupGroup: (
        _: { path: GroupCallPickupRemoveMembersFromCallPickupGroupPathParams },
    ) => Promise<BaseResponse<unknown>>;
    updateGroupCallPickupInformation: (
        _: {
            body?: GroupCallPickupUpdateGroupCallPickupInformationRequestBody;
            path: GroupCallPickupUpdateGroupCallPickupInformationPathParams;
        },
    ) => Promise<BaseResponse<unknown>>;
}

Readonlygroups

groups: {
    getGroupPhoneSettings: (
        _: {
            path: GroupsGetGroupPhoneSettingsPathParams;
            query?: GroupsGetGroupPhoneSettingsQueryParams;
        },
    ) => Promise<BaseResponse<GroupsGetGroupPhoneSettingsResponse>>;
}

ReadonlyinboundBlockedList

inboundBlockedList: {
    addAccountsInboundBlockRule: (
        _: { body: InboundBlockedListAddAccountsInboundBlockRuleRequestBody },
    ) => Promise<
        BaseResponse<InboundBlockedListAddAccountsInboundBlockRuleResponse>,
    >;
    addExtensionsInboundBlockRule: (
        _: {
            body: InboundBlockedListAddExtensionsInboundBlockRuleRequestBody;
            path: InboundBlockedListAddExtensionsInboundBlockRulePathParams;
        },
    ) => Promise<
        BaseResponse<InboundBlockedListAddExtensionsInboundBlockRuleResponse>,
    >;
    deleteAccountsInboundBlockedStatistics: (
        _: {
            query: InboundBlockedListDeleteAccountsInboundBlockedStatisticsQueryParams;
        },
    ) => Promise<BaseResponse<unknown>>;
    deleteAccountsInboundBlockRule: (
        _: {
            query: InboundBlockedListDeleteAccountsInboundBlockRuleQueryParams;
        },
    ) => Promise<BaseResponse<unknown>>;
    deleteExtensionsInboundBlockRule: (
        _: {
            path: InboundBlockedListDeleteExtensionsInboundBlockRulePathParams;
            query: InboundBlockedListDeleteExtensionsInboundBlockRuleQueryParams;
        },
    ) => Promise<BaseResponse<unknown>>;
    listAccountsInboundBlockedStatistics: (
        _: {
            query?: InboundBlockedListListAccountsInboundBlockedStatisticsQueryParams;
        },
    ) => Promise<
        BaseResponse<
            InboundBlockedListListAccountsInboundBlockedStatisticsResponse,
        >,
    >;
    listAccountsInboundBlockRules: (
        _: {
            query?: InboundBlockedListListAccountsInboundBlockRulesQueryParams;
        },
    ) => Promise<
        BaseResponse<InboundBlockedListListAccountsInboundBlockRulesResponse>,
    >;
    listExtensionsInboundBlockRules: (
        _: {
            path: InboundBlockedListListExtensionsInboundBlockRulesPathParams;
            query?: InboundBlockedListListExtensionsInboundBlockRulesQueryParams;
        },
    ) => Promise<
        BaseResponse<InboundBlockedListListExtensionsInboundBlockRulesResponse>,
    >;
    markPhoneNumberAsBlockedForAllExtensions: (
        _: {
            body: InboundBlockedListMarkPhoneNumberAsBlockedForAllExtensionsRequestBody;
        },
    ) => Promise<BaseResponse<unknown>>;
    updateAccountsInboundBlockRule: (
        _: {
            body: InboundBlockedListUpdateAccountsInboundBlockRuleRequestBody;
            path: InboundBlockedListUpdateAccountsInboundBlockRulePathParams;
        },
    ) => Promise<BaseResponse<unknown>>;
}

ReadonlyiVR

iVR: {
    getAutoReceptionistIVR: (
        _: {
            path: IVRGetAutoReceptionistIVRPathParams;
            query?: IVRGetAutoReceptionistIVRQueryParams;
        },
    ) => Promise<BaseResponse<IVRGetAutoReceptionistIVRResponse>>;
    updateAutoReceptionistIVR: (
        _: {
            body?: IVRUpdateAutoReceptionistIVRRequestBody;
            path: IVRUpdateAutoReceptionistIVRPathParams;
        },
    ) => Promise<BaseResponse<unknown>>;
}

ReadonlylineKeys

lineKeys: {
    batchUpdateLineKeyPositionAndSettingsInformation: (
        _: {
            body?: LineKeysBatchUpdateLineKeyPositionAndSettingsInformationRequestBody;
            path: LineKeysBatchUpdateLineKeyPositionAndSettingsInformationPathParams;
        },
    ) => Promise<BaseResponse<unknown>>;
    deleteLineKeySetting: (
        _: { path: LineKeysDeleteLineKeySettingPathParams },
    ) => Promise<BaseResponse<unknown>>;
    getLineKeyPositionAndSettingsInformation: (
        _: { path: LineKeysGetLineKeyPositionAndSettingsInformationPathParams },
    ) => Promise<
        BaseResponse<LineKeysGetLineKeyPositionAndSettingsInformationResponse>,
    >;
}

ReadonlymonitoringGroups

monitoringGroups: {
    addMembersToMonitoringGroup: (
        _: {
            body: MonitoringGroupsAddMembersToMonitoringGroupRequestBody;
            path: MonitoringGroupsAddMembersToMonitoringGroupPathParams;
            query: MonitoringGroupsAddMembersToMonitoringGroupQueryParams;
        },
    ) => Promise<BaseResponse<unknown>>;
    createMonitoringGroup: (
        _: { body?: MonitoringGroupsCreateMonitoringGroupRequestBody },
    ) => Promise<BaseResponse<MonitoringGroupsCreateMonitoringGroupResponse>>;
    deleteMonitoringGroup: (
        _: { path: MonitoringGroupsDeleteMonitoringGroupPathParams },
    ) => Promise<BaseResponse<unknown>>;
    getListOfMonitoringGroupsOnAccount: (
        _: {
            query?: MonitoringGroupsGetListOfMonitoringGroupsOnAccountQueryParams;
        },
    ) => Promise<
        BaseResponse<
            MonitoringGroupsGetListOfMonitoringGroupsOnAccountResponse,
        >,
    >;
    getMembersOfMonitoringGroup: (
        _: {
            path: MonitoringGroupsGetMembersOfMonitoringGroupPathParams;
            query: MonitoringGroupsGetMembersOfMonitoringGroupQueryParams;
        },
    ) => Promise<
        BaseResponse<MonitoringGroupsGetMembersOfMonitoringGroupResponse>,
    >;
    getMonitoringGroupByID: (
        _: { path: MonitoringGroupsGetMonitoringGroupByIDPathParams },
    ) => Promise<BaseResponse<MonitoringGroupsGetMonitoringGroupByIDResponse>>;
    removeAllMonitorsOrMonitoredMembersFromMonitoringGroup: (
        _: {
            path: MonitoringGroupsRemoveAllMonitorsOrMonitoredMembersFromMonitoringGroupPathParams;
            query: MonitoringGroupsRemoveAllMonitorsOrMonitoredMembersFromMonitoringGroupQueryParams;
        },
    ) => Promise<BaseResponse<unknown>>;
    removeMemberFromMonitoringGroup: (
        _: {
            path: MonitoringGroupsRemoveMemberFromMonitoringGroupPathParams;
            query?: MonitoringGroupsRemoveMemberFromMonitoringGroupQueryParams;
        },
    ) => Promise<BaseResponse<unknown>>;
    updateMonitoringGroup: (
        _: {
            body?: MonitoringGroupsUpdateMonitoringGroupRequestBody;
            path: MonitoringGroupsUpdateMonitoringGroupPathParams;
        },
    ) => Promise<BaseResponse<unknown>>;
}

ReadonlyoutboundCalling

outboundCalling: {
    addAccountLevelOutboundCallingExceptionRule: (
        _: {
            body?: OutboundCallingAddAccountLevelOutboundCallingExceptionRuleRequestBody;
        },
    ) => Promise<
        BaseResponse<
            OutboundCallingAddAccountLevelOutboundCallingExceptionRuleResponse,
        >,
    >;
    addCommonAreaLevelOutboundCallingExceptionRule: (
        _: {
            body?: OutboundCallingAddCommonAreaLevelOutboundCallingExceptionRuleRequestBody;
            path: OutboundCallingAddCommonAreaLevelOutboundCallingExceptionRulePathParams;
        },
    ) => Promise<
        BaseResponse<
            OutboundCallingAddCommonAreaLevelOutboundCallingExceptionRuleResponse,
        >,
    >;
    addSiteLevelOutboundCallingExceptionRule: (
        _: {
            body?: OutboundCallingAddSiteLevelOutboundCallingExceptionRuleRequestBody;
            path: OutboundCallingAddSiteLevelOutboundCallingExceptionRulePathParams;
        },
    ) => Promise<
        BaseResponse<
            OutboundCallingAddSiteLevelOutboundCallingExceptionRuleResponse,
        >,
    >;
    addUserLevelOutboundCallingExceptionRule: (
        _: {
            body?: OutboundCallingAddUserLevelOutboundCallingExceptionRuleRequestBody;
            path: OutboundCallingAddUserLevelOutboundCallingExceptionRulePathParams;
        },
    ) => Promise<
        BaseResponse<
            OutboundCallingAddUserLevelOutboundCallingExceptionRuleResponse,
        >,
    >;
    deleteAccountLevelOutboundCallingExceptionRule: (
        _: {
            path: OutboundCallingDeleteAccountLevelOutboundCallingExceptionRulePathParams;
        },
    ) => Promise<BaseResponse<unknown>>;
    deleteCommonAreaLevelOutboundCallingExceptionRule: (
        _: {
            path: OutboundCallingDeleteCommonAreaLevelOutboundCallingExceptionRulePathParams;
        },
    ) => Promise<BaseResponse<unknown>>;
    deleteSiteLevelOutboundCallingExceptionRule: (
        _: {
            path: OutboundCallingDeleteSiteLevelOutboundCallingExceptionRulePathParams;
        },
    ) => Promise<BaseResponse<unknown>>;
    deleteUserLevelOutboundCallingExceptionRule: (
        _: {
            path: OutboundCallingDeleteUserLevelOutboundCallingExceptionRulePathParams;
        },
    ) => Promise<BaseResponse<unknown>>;
    getAccountLevelOutboundCallingCountriesAndRegions: (
        _: {
            query?: OutboundCallingGetAccountLevelOutboundCallingCountriesAndRegionsQueryParams;
        },
    ) => Promise<
        BaseResponse<
            OutboundCallingGetAccountLevelOutboundCallingCountriesAndRegionsResponse,
        >,
    >;
    getCommonAreaLevelOutboundCallingCountriesAndRegions: (
        _: {
            path: OutboundCallingGetCommonAreaLevelOutboundCallingCountriesAndRegionsPathParams;
            query?: OutboundCallingGetCommonAreaLevelOutboundCallingCountriesAndRegionsQueryParams;
        },
    ) => Promise<
        BaseResponse<
            OutboundCallingGetCommonAreaLevelOutboundCallingCountriesAndRegionsResponse,
        >,
    >;
    getSiteLevelOutboundCallingCountriesAndRegions: (
        _: {
            path: OutboundCallingGetSiteLevelOutboundCallingCountriesAndRegionsPathParams;
            query?: OutboundCallingGetSiteLevelOutboundCallingCountriesAndRegionsQueryParams;
        },
    ) => Promise<
        BaseResponse<
            OutboundCallingGetSiteLevelOutboundCallingCountriesAndRegionsResponse,
        >,
    >;
    getUserLevelOutboundCallingCountriesAndRegions: (
        _: {
            path: OutboundCallingGetUserLevelOutboundCallingCountriesAndRegionsPathParams;
            query?: OutboundCallingGetUserLevelOutboundCallingCountriesAndRegionsQueryParams;
        },
    ) => Promise<
        BaseResponse<
            OutboundCallingGetUserLevelOutboundCallingCountriesAndRegionsResponse,
        >,
    >;
    listAccountLevelOutboundCallingExceptionRules: (
        _: {
            query?: OutboundCallingListAccountLevelOutboundCallingExceptionRulesQueryParams;
        },
    ) => Promise<
        BaseResponse<
            OutboundCallingListAccountLevelOutboundCallingExceptionRulesResponse,
        >,
    >;
    listCommonAreaLevelOutboundCallingExceptionRules: (
        _: {
            path: OutboundCallingListCommonAreaLevelOutboundCallingExceptionRulesPathParams;
            query?: OutboundCallingListCommonAreaLevelOutboundCallingExceptionRulesQueryParams;
        },
    ) => Promise<
        BaseResponse<
            OutboundCallingListCommonAreaLevelOutboundCallingExceptionRulesResponse,
        >,
    >;
    listSiteLevelOutboundCallingExceptionRules: (
        _: {
            path: OutboundCallingListSiteLevelOutboundCallingExceptionRulesPathParams;
            query?: OutboundCallingListSiteLevelOutboundCallingExceptionRulesQueryParams;
        },
    ) => Promise<
        BaseResponse<
            OutboundCallingListSiteLevelOutboundCallingExceptionRulesResponse,
        >,
    >;
    listUserLevelOutboundCallingExceptionRules: (
        _: {
            path: OutboundCallingListUserLevelOutboundCallingExceptionRulesPathParams;
            query?: OutboundCallingListUserLevelOutboundCallingExceptionRulesQueryParams;
        },
    ) => Promise<
        BaseResponse<
            OutboundCallingListUserLevelOutboundCallingExceptionRulesResponse,
        >,
    >;
    updateAccountLevelOutboundCallingCountriesOrRegions: (
        _: {
            body?: OutboundCallingUpdateAccountLevelOutboundCallingCountriesOrRegionsRequestBody;
        },
    ) => Promise<BaseResponse<unknown>>;
    updateAccountLevelOutboundCallingExceptionRule: (
        _: {
            body?: OutboundCallingUpdateAccountLevelOutboundCallingExceptionRuleRequestBody;
            path: OutboundCallingUpdateAccountLevelOutboundCallingExceptionRulePathParams;
        },
    ) => Promise<BaseResponse<unknown>>;
    updateCommonAreaLevelOutboundCallingCountriesOrRegions: (
        _: {
            body?: OutboundCallingUpdateCommonAreaLevelOutboundCallingCountriesOrRegionsRequestBody;
            path: OutboundCallingUpdateCommonAreaLevelOutboundCallingCountriesOrRegionsPathParams;
        },
    ) => Promise<BaseResponse<unknown>>;
    updateCommonAreaLevelOutboundCallingExceptionRule: (
        _: {
            body?: OutboundCallingUpdateCommonAreaLevelOutboundCallingExceptionRuleRequestBody;
            path: OutboundCallingUpdateCommonAreaLevelOutboundCallingExceptionRulePathParams;
        },
    ) => Promise<BaseResponse<unknown>>;
    updateSiteLevelOutboundCallingCountriesOrRegions: (
        _: {
            body?: OutboundCallingUpdateSiteLevelOutboundCallingCountriesOrRegionsRequestBody;
            path: OutboundCallingUpdateSiteLevelOutboundCallingCountriesOrRegionsPathParams;
        },
    ) => Promise<BaseResponse<unknown>>;
    updateSiteLevelOutboundCallingExceptionRule: (
        _: {
            body?: OutboundCallingUpdateSiteLevelOutboundCallingExceptionRuleRequestBody;
            path: OutboundCallingUpdateSiteLevelOutboundCallingExceptionRulePathParams;
        },
    ) => Promise<BaseResponse<unknown>>;
    updateUserLevelOutboundCallingCountriesOrRegions: (
        _: {
            body?: OutboundCallingUpdateUserLevelOutboundCallingCountriesOrRegionsRequestBody;
            path: OutboundCallingUpdateUserLevelOutboundCallingCountriesOrRegionsPathParams;
        },
    ) => Promise<BaseResponse<unknown>>;
    updateUserLevelOutboundCallingExceptionRule: (
        _: {
            body?: OutboundCallingUpdateUserLevelOutboundCallingExceptionRuleRequestBody;
            path: OutboundCallingUpdateUserLevelOutboundCallingExceptionRulePathParams;
        },
    ) => Promise<BaseResponse<unknown>>;
}

ReadonlyphoneDevices

phoneDevices: {
    addDevice: (
        _: { body: PhoneDevicesAddDeviceRequestBody },
    ) => Promise<BaseResponse<PhoneDevicesAddDeviceResponse>>;
    assignEntityToDevice: (
        _: {
            body: PhoneDevicesAssignEntityToDeviceRequestBody;
            path: PhoneDevicesAssignEntityToDevicePathParams;
        },
    ) => Promise<BaseResponse<unknown>>;
    deleteDevice: (
        _: { path: PhoneDevicesDeleteDevicePathParams },
    ) => Promise<BaseResponse<unknown>>;
    getDeviceDetails: (
        _: { path: PhoneDevicesGetDeviceDetailsPathParams },
    ) => Promise<BaseResponse<PhoneDevicesGetDeviceDetailsResponse>>;
    listDevices: (
        _: { query: PhoneDevicesListDevicesQueryParams },
    ) => Promise<BaseResponse<PhoneDevicesListDevicesResponse>>;
    rebootDeskPhone: (
        _: { path: PhoneDevicesRebootDeskPhonePathParams },
    ) => Promise<BaseResponse<unknown>>;
    syncDeskphones: (
        _: { body: PhoneDevicesSyncDeskphonesRequestBody },
    ) => Promise<BaseResponse<unknown>>;
    unassignEntityFromDevice: (
        _: { path: PhoneDevicesUnassignEntityFromDevicePathParams },
    ) => Promise<BaseResponse<unknown>>;
    updateDevice: (
        _: {
            body?: PhoneDevicesUpdateDeviceRequestBody;
            path: PhoneDevicesUpdateDevicePathParams;
        },
    ) => Promise<BaseResponse<unknown>>;
    updateProvisionTemplateOfDevice: (
        _: {
            body?: PhoneDevicesUpdateProvisionTemplateOfDeviceRequestBody;
            path: PhoneDevicesUpdateProvisionTemplateOfDevicePathParams;
        },
    ) => Promise<BaseResponse<unknown>>;
}

ReadonlyphoneNumbers

phoneNumbers: {
    addBYOCPhoneNumbers: (
        _: { body: PhoneNumbersAddBYOCPhoneNumbersRequestBody },
    ) => Promise<BaseResponse<PhoneNumbersAddBYOCPhoneNumbersResponse>>;
    assignPhoneNumberToUser: (
        _: {
            body?: PhoneNumbersAssignPhoneNumberToUserRequestBody;
            path: PhoneNumbersAssignPhoneNumberToUserPathParams;
        },
    ) => Promise<BaseResponse<PhoneNumbersAssignPhoneNumberToUserResponse>>;
    deleteUnassignedPhoneNumbers: (
        _: { query: PhoneNumbersDeleteUnassignedPhoneNumbersQueryParams },
    ) => Promise<BaseResponse<unknown>>;
    getPhoneNumber: (
        _: { path: PhoneNumbersGetPhoneNumberPathParams },
    ) => Promise<BaseResponse<PhoneNumbersGetPhoneNumberResponse>>;
    listPhoneNumbers: (
        _: { query?: PhoneNumbersListPhoneNumbersQueryParams },
    ) => Promise<BaseResponse<PhoneNumbersListPhoneNumbersResponse>>;
    unassignPhoneNumber: (
        _: { path: PhoneNumbersUnassignPhoneNumberPathParams },
    ) => Promise<BaseResponse<unknown>>;
    updatePhoneNumber: (
        _: {
            body?: PhoneNumbersUpdatePhoneNumberRequestBody;
            path: PhoneNumbersUpdatePhoneNumberPathParams;
        },
    ) => Promise<BaseResponse<unknown>>;
    updateSitesUnassignedPhoneNumbers: (
        _: {
            body?: PhoneNumbersUpdateSitesUnassignedPhoneNumbersRequestBody;
            path: PhoneNumbersUpdateSitesUnassignedPhoneNumbersPathParams;
        },
    ) => Promise<BaseResponse<unknown>>;
}

ReadonlyphonePlans

phonePlans: {
    listCallingPlans: (
        _: {},
    ) => Promise<BaseResponse<PhonePlansListCallingPlansResponse>>;
    listPlanInformation: (
        _: {},
    ) => Promise<BaseResponse<PhonePlansListPlanInformationResponse>>;
}

ReadonlyphoneRoles

phoneRoles: {
    addMembersToRoles: (
        _: {
            body?: PhoneRolesAddMembersToRolesRequestBody;
            path: PhoneRolesAddMembersToRolesPathParams;
        },
    ) => Promise<BaseResponse<unknown>>;
    deleteMembersInRole: (
        _: {
            path: PhoneRolesDeleteMembersInRolePathParams;
            query: PhoneRolesDeleteMembersInRoleQueryParams;
        },
    ) => Promise<BaseResponse<unknown>>;
    deletePhoneRole: (
        _: { path: PhoneRolesDeletePhoneRolePathParams },
    ) => Promise<BaseResponse<unknown>>;
    duplicatePhoneRole: (
        _: { body: PhoneRolesDuplicatePhoneRoleRequestBody },
    ) => Promise<BaseResponse<PhoneRolesDuplicatePhoneRoleResponse>>;
    getRoleInformation: (
        _: { path: PhoneRolesGetRoleInformationPathParams },
    ) => Promise<BaseResponse<PhoneRolesGetRoleInformationResponse>>;
    listMembersInRole: (
        _: {
            path: PhoneRolesListMembersInRolePathParams;
            query?: PhoneRolesListMembersInRoleQueryParams;
        },
    ) => Promise<BaseResponse<PhoneRolesListMembersInRoleResponse>>;
    listPhoneRoles: (
        _: {},
    ) => Promise<BaseResponse<PhoneRolesListPhoneRolesResponse>>;
    updatePhoneRole: (
        _: {
            body?: PhoneRolesUpdatePhoneRoleRequestBody;
            path: PhoneRolesUpdatePhoneRolePathParams;
        },
    ) => Promise<BaseResponse<unknown>>;
}

ReadonlyprivateDirectory

privateDirectory: {
    addMembersToPrivateDirectory: (
        _: { body: PrivateDirectoryAddMembersToPrivateDirectoryRequestBody },
    ) => Promise<BaseResponse<unknown>>;
    listPrivateDirectoryMembers: (
        _: { query?: PrivateDirectoryListPrivateDirectoryMembersQueryParams },
    ) => Promise<
        BaseResponse<PrivateDirectoryListPrivateDirectoryMembersResponse>,
    >;
    removeMemberFromPrivateDirectory: (
        _: {
            path: PrivateDirectoryRemoveMemberFromPrivateDirectoryPathParams;
            query?: PrivateDirectoryRemoveMemberFromPrivateDirectoryQueryParams;
        },
    ) => Promise<BaseResponse<unknown>>;
    updatePrivateDirectoryMember: (
        _: {
            body: PrivateDirectoryUpdatePrivateDirectoryMemberRequestBody;
            path: PrivateDirectoryUpdatePrivateDirectoryMemberPathParams;
        },
    ) => Promise<BaseResponse<unknown>>;
}

ReadonlyproviderExchange

providerExchange: {
    addPeeringPhoneNumbers: (
        _: { body?: ProviderExchangeAddPeeringPhoneNumbersRequestBody },
    ) => Promise<BaseResponse<ProviderExchangeAddPeeringPhoneNumbersResponse>>;
    listCarrierPeeringPhoneNumbers: (
        _: {
            query?: ProviderExchangeListCarrierPeeringPhoneNumbersQueryParams;
        },
    ) => Promise<
        BaseResponse<ProviderExchangeListCarrierPeeringPhoneNumbersResponse>,
    >;
    listPeeringPhoneNumbers: (
        _: { query?: ProviderExchangeListPeeringPhoneNumbersQueryParams },
    ) => Promise<BaseResponse<ProviderExchangeListPeeringPhoneNumbersResponse>>;
    removePeeringPhoneNumbers: (
        _: { query: ProviderExchangeRemovePeeringPhoneNumbersQueryParams },
    ) => Promise<
        BaseResponse<ProviderExchangeRemovePeeringPhoneNumbersResponse>,
    >;
    updatePeeringPhoneNumbers: (
        _: { body?: ProviderExchangeUpdatePeeringPhoneNumbersRequestBody },
    ) => Promise<
        BaseResponse<ProviderExchangeUpdatePeeringPhoneNumbersResponse>,
    >;
}

ReadonlyprovisionTemplates

provisionTemplates: {
    addProvisionTemplate: (
        _: { body: ProvisionTemplatesAddProvisionTemplateRequestBody },
    ) => Promise<BaseResponse<ProvisionTemplatesAddProvisionTemplateResponse>>;
    deleteProvisionTemplate: (
        _: { path: ProvisionTemplatesDeleteProvisionTemplatePathParams },
    ) => Promise<BaseResponse<unknown>>;
    getProvisionTemplate: (
        _: { path: ProvisionTemplatesGetProvisionTemplatePathParams },
    ) => Promise<BaseResponse<ProvisionTemplatesGetProvisionTemplateResponse>>;
    listProvisionTemplates: (
        _: { query?: ProvisionTemplatesListProvisionTemplatesQueryParams },
    ) => Promise<
        BaseResponse<ProvisionTemplatesListProvisionTemplatesResponse>,
    >;
    updateProvisionTemplate: (
        _: {
            body?: ProvisionTemplatesUpdateProvisionTemplateRequestBody;
            path: ProvisionTemplatesUpdateProvisionTemplatePathParams;
        },
    ) => Promise<BaseResponse<unknown>>;
}

Readonlyrecordings

recordings: {
    deleteCallRecording: (
        _: { path: RecordingsDeleteCallRecordingPathParams },
    ) => Promise<BaseResponse<unknown>>;
    downloadPhoneRecording: (
        _: { path: RecordingsDownloadPhoneRecordingPathParams },
    ) => Promise<BaseResponse<unknown>>;
    downloadPhoneRecordingTranscript: (
        _: { path: RecordingsDownloadPhoneRecordingTranscriptPathParams },
    ) => Promise<BaseResponse<unknown>>;
    getCallRecordings: (
        _: { query?: RecordingsGetCallRecordingsQueryParams },
    ) => Promise<BaseResponse<RecordingsGetCallRecordingsResponse>>;
    getRecordingByCallID: (
        _: { path: RecordingsGetRecordingByCallIDPathParams },
    ) => Promise<BaseResponse<RecordingsGetRecordingByCallIDResponse>>;
    getUsersRecordings: (
        _: {
            path: RecordingsGetUsersRecordingsPathParams;
            query?: RecordingsGetUsersRecordingsQueryParams;
        },
    ) => Promise<BaseResponse<RecordingsGetUsersRecordingsResponse>>;
    updateAutoDeleteField: (
        _: {
            body?: RecordingsUpdateAutoDeleteFieldRequestBody;
            path: RecordingsUpdateAutoDeleteFieldPathParams;
        },
    ) => Promise<BaseResponse<unknown>>;
    updateRecordingStatus: (
        _: {
            body?: RecordingsUpdateRecordingStatusRequestBody;
            path: RecordingsUpdateRecordingStatusPathParams;
        },
    ) => Promise<BaseResponse<unknown>>;
}

Readonlyreports

reports: {
    getCallChargesUsageReport: (
        _: { query?: ReportsGetCallChargesUsageReportQueryParams },
    ) => Promise<BaseResponse<ReportsGetCallChargesUsageReportResponse>>;
    getOperationLogsReport: (
        _: { query?: ReportsGetOperationLogsReportQueryParams },
    ) => Promise<BaseResponse<ReportsGetOperationLogsReportResponse>>;
    getSMSMMSChargesUsageReport: (
        _: { query?: ReportsGetSMSMMSChargesUsageReportQueryParams },
    ) => Promise<BaseResponse<ReportsGetSMSMMSChargesUsageReportResponse>>;
}

ReadonlyroutingRules

routingRules: {
    addDirectoryBackupRoutingRule: (
        _: { body?: RoutingRulesAddDirectoryBackupRoutingRuleRequestBody },
    ) => Promise<
        BaseResponse<RoutingRulesAddDirectoryBackupRoutingRuleResponse>,
    >;
    deleteDirectoryBackupRoutingRule: (
        _: { path: RoutingRulesDeleteDirectoryBackupRoutingRulePathParams },
    ) => Promise<BaseResponse<unknown>>;
    getDirectoryBackupRoutingRule: (
        _: { path: RoutingRulesGetDirectoryBackupRoutingRulePathParams },
    ) => Promise<
        BaseResponse<RoutingRulesGetDirectoryBackupRoutingRuleResponse>,
    >;
    listDirectoryBackupRoutingRules: (
        _: { query?: RoutingRulesListDirectoryBackupRoutingRulesQueryParams },
    ) => Promise<
        BaseResponse<RoutingRulesListDirectoryBackupRoutingRulesResponse>,
    >;
    updateDirectoryBackupRoutingRule: (
        _: {
            body?: RoutingRulesUpdateDirectoryBackupRoutingRuleRequestBody;
            path: RoutingRulesUpdateDirectoryBackupRoutingRulePathParams;
        },
    ) => Promise<BaseResponse<unknown>>;
}

Readonlysettings

settings: {
    getPhoneAccountSettings: (
        _: {},
    ) => Promise<BaseResponse<SettingsGetPhoneAccountSettingsResponse>>;
    getPortedNumberDetails: (
        _: { path: SettingsGetPortedNumberDetailsPathParams },
    ) => Promise<BaseResponse<SettingsGetPortedNumberDetailsResponse>>;
    listBYOCSIPTrunks: (
        _: { query?: SettingsListBYOCSIPTrunksQueryParams },
    ) => Promise<BaseResponse<SettingsListBYOCSIPTrunksResponse>>;
    listPortedNumbers: (
        _: { query?: SettingsListPortedNumbersQueryParams },
    ) => Promise<BaseResponse<SettingsListPortedNumbersResponse>>;
    listSIPGroups: (
        _: { query?: SettingsListSIPGroupsQueryParams },
    ) => Promise<BaseResponse<SettingsListSIPGroupsResponse>>;
    updatePhoneAccountSettings: (
        _: { body?: SettingsUpdatePhoneAccountSettingsRequestBody },
    ) => Promise<BaseResponse<unknown>>;
}

ReadonlysettingTemplates

settingTemplates: {
    addSettingTemplate: (
        _: { body: SettingTemplatesAddSettingTemplateRequestBody },
    ) => Promise<BaseResponse<SettingTemplatesAddSettingTemplateResponse>>;
    getSettingTemplateDetails: (
        _: {
            path: SettingTemplatesGetSettingTemplateDetailsPathParams;
            query?: SettingTemplatesGetSettingTemplateDetailsQueryParams;
        },
    ) => Promise<
        BaseResponse<SettingTemplatesGetSettingTemplateDetailsResponse>,
    >;
    listSettingTemplates: (
        _: { query?: SettingTemplatesListSettingTemplatesQueryParams },
    ) => Promise<BaseResponse<SettingTemplatesListSettingTemplatesResponse>>;
    updateSettingTemplate: (
        _: {
            body?: SettingTemplatesUpdateSettingTemplateRequestBody;
            path: SettingTemplatesUpdateSettingTemplatePathParams;
        },
    ) => Promise<BaseResponse<unknown>>;
}

ReadonlysharedLineAppearance

sharedLineAppearance: {
    listSharedLineAppearances: (
        _: { query?: SharedLineAppearanceListSharedLineAppearancesQueryParams },
    ) => Promise<
        BaseResponse<SharedLineAppearanceListSharedLineAppearancesResponse>,
    >;
}

ReadonlysharedLineGroup

sharedLineGroup: {
    addMembersToSharedLineGroup: (
        _: {
            body?: SharedLineGroupAddMembersToSharedLineGroupRequestBody;
            path: SharedLineGroupAddMembersToSharedLineGroupPathParams;
        },
    ) => Promise<BaseResponse<unknown>>;
    addPolicySettingToSharedLineGroup: (
        _: {
            body?: SharedLineGroupAddPolicySettingToSharedLineGroupRequestBody;
            path: SharedLineGroupAddPolicySettingToSharedLineGroupPathParams;
        },
    ) => Promise<
        BaseResponse<SharedLineGroupAddPolicySettingToSharedLineGroupResponse>,
    >;
    assignPhoneNumbers: (
        _: {
            body?: SharedLineGroupAssignPhoneNumbersRequestBody;
            path: SharedLineGroupAssignPhoneNumbersPathParams;
        },
    ) => Promise<BaseResponse<unknown>>;
    createSharedLineGroup: (
        _: { body: SharedLineGroupCreateSharedLineGroupRequestBody },
    ) => Promise<BaseResponse<SharedLineGroupCreateSharedLineGroupResponse>>;
    deleteSharedLineGroup: (
        _: { path: SharedLineGroupDeleteSharedLineGroupPathParams },
    ) => Promise<BaseResponse<unknown>>;
    deleteSLGPolicySetting: (
        _: {
            path: SharedLineGroupDeleteSLGPolicySettingPathParams;
            query: SharedLineGroupDeleteSLGPolicySettingQueryParams;
        },
    ) => Promise<BaseResponse<unknown>>;
    getSharedLineGroup: (
        _: { path: SharedLineGroupGetSharedLineGroupPathParams },
    ) => Promise<BaseResponse<SharedLineGroupGetSharedLineGroupResponse>>;
    getSharedLineGroupPolicy: (
        _: { path: SharedLineGroupGetSharedLineGroupPolicyPathParams },
    ) => Promise<BaseResponse<SharedLineGroupGetSharedLineGroupPolicyResponse>>;
    listSharedLineGroups: (
        _: { query?: SharedLineGroupListSharedLineGroupsQueryParams },
    ) => Promise<BaseResponse<SharedLineGroupListSharedLineGroupsResponse>>;
    unassignAllPhoneNumbers: (
        _: { path: SharedLineGroupUnassignAllPhoneNumbersPathParams },
    ) => Promise<BaseResponse<unknown>>;
    unassignMemberFromSharedLineGroup: (
        _: { path: SharedLineGroupUnassignMemberFromSharedLineGroupPathParams },
    ) => Promise<BaseResponse<unknown>>;
    unassignMembersFromSharedLineGroup: (
        _: {
            path: SharedLineGroupUnassignMembersFromSharedLineGroupPathParams;
        },
    ) => Promise<BaseResponse<unknown>>;
    unassignPhoneNumber: (
        _: { path: SharedLineGroupUnassignPhoneNumberPathParams },
    ) => Promise<BaseResponse<unknown>>;
    updateSharedLineGroup: (
        _: {
            body?: SharedLineGroupUpdateSharedLineGroupRequestBody;
            path: SharedLineGroupUpdateSharedLineGroupPathParams;
        },
    ) => Promise<BaseResponse<unknown>>;
    updateSharedLineGroupPolicy: (
        _: {
            body?: SharedLineGroupUpdateSharedLineGroupPolicyRequestBody;
            path: SharedLineGroupUpdateSharedLineGroupPolicyPathParams;
        },
    ) => Promise<BaseResponse<unknown>>;
    updateSLGPolicySetting: (
        _: {
            body?: SharedLineGroupUpdateSLGPolicySettingRequestBody;
            path: SharedLineGroupUpdateSLGPolicySettingPathParams;
        },
    ) => Promise<BaseResponse<unknown>>;
}

Readonlysites

sites: {
    addCustomizedOutboundCallerIDPhoneNumbers: (
        _: {
            body?: SitesAddCustomizedOutboundCallerIDPhoneNumbersRequestBody;
            path: SitesAddCustomizedOutboundCallerIDPhoneNumbersPathParams;
        },
    ) => Promise<BaseResponse<unknown>>;
    addSiteSetting: (
        _: {
            body?: SitesAddSiteSettingRequestBody;
            path: SitesAddSiteSettingPathParams;
        },
    ) => Promise<BaseResponse<SitesAddSiteSettingResponse>>;
    createPhoneSite: (
        _: { body: SitesCreatePhoneSiteRequestBody },
    ) => Promise<BaseResponse<SitesCreatePhoneSiteResponse>>;
    deletePhoneSite: (
        _: {
            path: SitesDeletePhoneSitePathParams;
            query: SitesDeletePhoneSiteQueryParams;
        },
    ) => Promise<BaseResponse<unknown>>;
    deleteSiteSetting: (
        _: {
            path: SitesDeleteSiteSettingPathParams;
            query?: SitesDeleteSiteSettingQueryParams;
        },
    ) => Promise<BaseResponse<unknown>>;
    getPhoneSiteDetails: (
        _: { path: SitesGetPhoneSiteDetailsPathParams },
    ) => Promise<BaseResponse<SitesGetPhoneSiteDetailsResponse>>;
    getPhoneSiteSetting: (
        _: { path: SitesGetPhoneSiteSettingPathParams },
    ) => Promise<BaseResponse<SitesGetPhoneSiteSettingResponse>>;
    listCustomizedOutboundCallerIDPhoneNumbers: (
        _: {
            path: SitesListCustomizedOutboundCallerIDPhoneNumbersPathParams;
            query?: SitesListCustomizedOutboundCallerIDPhoneNumbersQueryParams;
        },
    ) => Promise<
        BaseResponse<SitesListCustomizedOutboundCallerIDPhoneNumbersResponse>,
    >;
    listPhoneSites: (
        _: { query?: SitesListPhoneSitesQueryParams },
    ) => Promise<BaseResponse<SitesListPhoneSitesResponse>>;
    removeCustomizedOutboundCallerIDPhoneNumbers: (
        _: {
            path: SitesRemoveCustomizedOutboundCallerIDPhoneNumbersPathParams;
            query?: SitesRemoveCustomizedOutboundCallerIDPhoneNumbersQueryParams;
        },
    ) => Promise<BaseResponse<unknown>>;
    updatePhoneSiteDetails: (
        _: {
            body?: SitesUpdatePhoneSiteDetailsRequestBody;
            path: SitesUpdatePhoneSiteDetailsPathParams;
        },
    ) => Promise<BaseResponse<unknown>>;
    updateSiteSetting: (
        _: {
            body?: SitesUpdateSiteSettingRequestBody;
            path: SitesUpdateSiteSettingPathParams;
        },
    ) => Promise<BaseResponse<unknown>>;
}

ReadonlysMS

sMS: {
    getAccountsSMSSessions: (
        _: { query?: SMSGetAccountsSMSSessionsQueryParams },
    ) => Promise<BaseResponse<SMSGetAccountsSMSSessionsResponse>>;
    getSMSByMessageID: (
        _: { path: SMSGetSMSByMessageIDPathParams },
    ) => Promise<BaseResponse<SMSGetSMSByMessageIDResponse>>;
    getSMSSessionDetails: (
        _: {
            path: SMSGetSMSSessionDetailsPathParams;
            query?: SMSGetSMSSessionDetailsQueryParams;
        },
    ) => Promise<BaseResponse<SMSGetSMSSessionDetailsResponse>>;
    getUsersSMSSessions: (
        _: {
            path: SMSGetUsersSMSSessionsPathParams;
            query?: SMSGetUsersSMSSessionsQueryParams;
        },
    ) => Promise<BaseResponse<SMSGetUsersSMSSessionsResponse>>;
    listUsersSMSSessionsInDescendingOrder: (
        _: {
            path: SMSListUsersSMSSessionsInDescendingOrderPathParams;
            query: SMSListUsersSMSSessionsInDescendingOrderQueryParams;
        },
    ) => Promise<
        BaseResponse<SMSListUsersSMSSessionsInDescendingOrderResponse>,
    >;
    syncSMSBySessionID: (
        _: {
            path: SMSSyncSMSBySessionIDPathParams;
            query?: SMSSyncSMSBySessionIDQueryParams;
        },
    ) => Promise<BaseResponse<SMSSyncSMSBySessionIDResponse>>;
}

ReadonlysMSCampaign

sMSCampaign: {
    assignPhoneNumberToSMSCampaign: (
        _: {
            body?: SMSCampaignAssignPhoneNumberToSMSCampaignRequestBody;
            path: SMSCampaignAssignPhoneNumberToSMSCampaignPathParams;
        },
    ) => Promise<
        BaseResponse<SMSCampaignAssignPhoneNumberToSMSCampaignResponse>,
    >;
    getSMSCampaign: (
        _: { path: SMSCampaignGetSMSCampaignPathParams },
    ) => Promise<BaseResponse<SMSCampaignGetSMSCampaignResponse>>;
    listOptStatusesOfPhoneNumbersAssignedToSMSCampaign: (
        _: {
            path: SMSCampaignListOptStatusesOfPhoneNumbersAssignedToSMSCampaignPathParams;
            query: SMSCampaignListOptStatusesOfPhoneNumbersAssignedToSMSCampaignQueryParams;
        },
    ) => Promise<
        BaseResponse<
            SMSCampaignListOptStatusesOfPhoneNumbersAssignedToSMSCampaignResponse,
        >,
    >;
    listSMSCampaigns: (
        _: { query?: SMSCampaignListSMSCampaignsQueryParams },
    ) => Promise<BaseResponse<SMSCampaignListSMSCampaignsResponse>>;
    unassignPhoneNumber: (
        _: { path: SMSCampaignUnassignPhoneNumberPathParams },
    ) => Promise<BaseResponse<unknown>>;
    updateOptStatusesOfPhoneNumbersAssignedToSMSCampaign: (
        _: {
            body: SMSCampaignUpdateOptStatusesOfPhoneNumbersAssignedToSMSCampaignRequestBody;
            path: SMSCampaignUpdateOptStatusesOfPhoneNumbersAssignedToSMSCampaignPathParams;
        },
    ) => Promise<BaseResponse<unknown>>;
}

Readonlyusers

users: {
    addPhoneNumbersForUsersCustomizedOutboundCallerID: (
        _: {
            body?: UsersAddPhoneNumbersForUsersCustomizedOutboundCallerIDRequestBody;
            path: UsersAddPhoneNumbersForUsersCustomizedOutboundCallerIDPathParams;
        },
    ) => Promise<BaseResponse<unknown>>;
    addUsersSharedAccessSetting: (
        _: {
            body?: UsersAddUsersSharedAccessSettingRequestBody;
            path: UsersAddUsersSharedAccessSettingPathParams;
        },
    ) => Promise<BaseResponse<UsersAddUsersSharedAccessSettingResponse>>;
    assignCallingPlanToUser: (
        _: {
            body?: UsersAssignCallingPlanToUserRequestBody;
            path: UsersAssignCallingPlanToUserPathParams;
        },
    ) => Promise<BaseResponse<unknown>>;
    batchAddUsers: (
        _: { body?: UsersBatchAddUsersRequestBody },
    ) => Promise<BaseResponse<UsersBatchAddUsersResponse>>;
    deleteUsersSharedAccessSetting: (
        _: {
            path: UsersDeleteUsersSharedAccessSettingPathParams;
            query?: UsersDeleteUsersSharedAccessSettingQueryParams;
        },
    ) => Promise<BaseResponse<unknown>>;
    getUsersProfile: (
        _: { path: UsersGetUsersProfilePathParams },
    ) => Promise<BaseResponse<UsersGetUsersProfileResponse>>;
    getUsersProfileSettings: (
        _: { path: UsersGetUsersProfileSettingsPathParams },
    ) => Promise<BaseResponse<UsersGetUsersProfileSettingsResponse>>;
    listPhoneUsers: (
        _: { query?: UsersListPhoneUsersQueryParams },
    ) => Promise<BaseResponse<UsersListPhoneUsersResponse>>;
    listUsersPhoneNumbersForCustomizedOutboundCallerID: (
        _: {
            path: UsersListUsersPhoneNumbersForCustomizedOutboundCallerIDPathParams;
            query?: UsersListUsersPhoneNumbersForCustomizedOutboundCallerIDQueryParams;
        },
    ) => Promise<
        BaseResponse<
            UsersListUsersPhoneNumbersForCustomizedOutboundCallerIDResponse,
        >,
    >;
    removeUsersCustomizedOutboundCallerIDPhoneNumbers: (
        _: {
            path: UsersRemoveUsersCustomizedOutboundCallerIDPhoneNumbersPathParams;
            query?: UsersRemoveUsersCustomizedOutboundCallerIDPhoneNumbersQueryParams;
        },
    ) => Promise<BaseResponse<unknown>>;
    unassignUsersCallingPlan: (
        _: {
            path: UsersUnassignUsersCallingPlanPathParams;
            query?: UsersUnassignUsersCallingPlanQueryParams;
        },
    ) => Promise<BaseResponse<unknown>>;
    updateMultipleUsersPropertiesInBatch: (
        _: { body?: UsersUpdateMultipleUsersPropertiesInBatchRequestBody },
    ) => Promise<BaseResponse<unknown>>;
    updateUsersCallingPlan: (
        _: {
            body: UsersUpdateUsersCallingPlanRequestBody;
            path: UsersUpdateUsersCallingPlanPathParams;
        },
    ) => Promise<BaseResponse<unknown>>;
    updateUsersProfile: (
        _: {
            body?: UsersUpdateUsersProfileRequestBody;
            path: UsersUpdateUsersProfilePathParams;
        },
    ) => Promise<BaseResponse<unknown>>;
    updateUsersProfileSettings: (
        _: {
            body?: UsersUpdateUsersProfileSettingsRequestBody;
            path: UsersUpdateUsersProfileSettingsPathParams;
        },
    ) => Promise<BaseResponse<unknown>>;
    updateUsersSharedAccessSetting: (
        _: {
            body?: UsersUpdateUsersSharedAccessSettingRequestBody;
            path: UsersUpdateUsersSharedAccessSettingPathParams;
        },
    ) => Promise<BaseResponse<unknown>>;
}

Readonlyvoicemails

voicemails: {
    downloadPhoneVoicemail: (
        _: { path: VoicemailsDownloadPhoneVoicemailPathParams },
    ) => Promise<BaseResponse<unknown>>;
    getAccountVoicemails: (
        _: { query?: VoicemailsGetAccountVoicemailsQueryParams },
    ) => Promise<BaseResponse<VoicemailsGetAccountVoicemailsResponse>>;
    getUsersVoicemails: (
        _: {
            path: VoicemailsGetUsersVoicemailsPathParams;
            query?: VoicemailsGetUsersVoicemailsQueryParams;
        },
    ) => Promise<BaseResponse<VoicemailsGetUsersVoicemailsResponse>>;
    getUserVoicemailDetailsFromCallLog: (
        _: { path: VoicemailsGetUserVoicemailDetailsFromCallLogPathParams },
    ) => Promise<
        BaseResponse<VoicemailsGetUserVoicemailDetailsFromCallLogResponse>,
    >;
    getVoicemailDetails: (
        _: { path: VoicemailsGetVoicemailDetailsPathParams },
    ) => Promise<BaseResponse<VoicemailsGetVoicemailDetailsResponse>>;
    updateVoicemailReadStatus: (
        _: {
            path: VoicemailsUpdateVoicemailReadStatusPathParams;
            query: VoicemailsUpdateVoicemailReadStatusQueryParams;
        },
    ) => Promise<BaseResponse<unknown>>;
}

ReadonlyzoomRooms

zoomRooms: {
    addZoomRoomToZoomPhone: (
        _: { body?: ZoomRoomsAddZoomRoomToZoomPhoneRequestBody },
    ) => Promise<BaseResponse<unknown>>;
    assignCallingPlansToZoomRoom: (
        _: {
            body?: ZoomRoomsAssignCallingPlansToZoomRoomRequestBody;
            path: ZoomRoomsAssignCallingPlansToZoomRoomPathParams;
        },
    ) => Promise<BaseResponse<unknown>>;
    assignPhoneNumbersToZoomRoom: (
        _: {
            body?: ZoomRoomsAssignPhoneNumbersToZoomRoomRequestBody;
            path: ZoomRoomsAssignPhoneNumbersToZoomRoomPathParams;
        },
    ) => Promise<BaseResponse<unknown>>;
    getZoomRoomUnderZoomPhoneLicense: (
        _: { path: ZoomRoomsGetZoomRoomUnderZoomPhoneLicensePathParams },
    ) => Promise<
        BaseResponse<ZoomRoomsGetZoomRoomUnderZoomPhoneLicenseResponse>,
    >;
    listZoomRoomsUnderZoomPhoneLicense: (
        _: { query?: ZoomRoomsListZoomRoomsUnderZoomPhoneLicenseQueryParams },
    ) => Promise<
        BaseResponse<ZoomRoomsListZoomRoomsUnderZoomPhoneLicenseResponse>,
    >;
    listZoomRoomsWithoutZoomPhoneAssignment: (
        _: {
            query?: ZoomRoomsListZoomRoomsWithoutZoomPhoneAssignmentQueryParams;
        },
    ) => Promise<
        BaseResponse<ZoomRoomsListZoomRoomsWithoutZoomPhoneAssignmentResponse>,
    >;
    removeCallingPlanFromZoomRoom: (
        _: {
            path: ZoomRoomsRemoveCallingPlanFromZoomRoomPathParams;
            query?: ZoomRoomsRemoveCallingPlanFromZoomRoomQueryParams;
        },
    ) => Promise<BaseResponse<unknown>>;
    removePhoneNumberFromZoomRoom: (
        _: { path: ZoomRoomsRemovePhoneNumberFromZoomRoomPathParams },
    ) => Promise<BaseResponse<unknown>>;
    removeZoomRoomFromZPAccount: (
        _: { path: ZoomRoomsRemoveZoomRoomFromZPAccountPathParams },
    ) => Promise<BaseResponse<unknown>>;
    updateZoomRoomUnderZoomPhoneLicense: (
        _: {
            body?: ZoomRoomsUpdateZoomRoomUnderZoomPhoneLicenseRequestBody;
            path: ZoomRoomsUpdateZoomRoomUnderZoomPhoneLicensePathParams;
        },
    ) => Promise<BaseResponse<unknown>>;
}

Settings

Member Visibility

On This Page

Constructors
Properties