voip-ms 0.1.1

// @generated by xtask from tools/server.wsdl.
// DO NOT EDIT — regenerate with `cargo xtask gen`.

#![allow(clippy::too_many_arguments)]
#![allow(non_snake_case)]

use serde::Serialize;
use serde::de::DeserializeOwned;
use serde_json::Value;

use crate::client::Client;
use crate::error::Result;

/// Parameters for [`Client::add_charge`] (wire method `addCharge`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct AddChargeParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub client: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub charge: Option<f64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub test: Option<bool>,
}

/// Parameters for [`Client::add_lnp_file`] (wire method `addLNPFile`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct AddLnpFileParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub portid: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub file: Option<String>,
}

/// Parameters for [`Client::add_lnp_port`] (wire method `addLNPPort`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct AddLnpPortParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub portType: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub numbers: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub isPartial: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub locationType: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub isMobile: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pin: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub btn: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub services: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tfType: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub statementName: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub firstName: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lastName: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub address1: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub address2: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub city: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub zip: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub state: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub country: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub providerName: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub providerAccount: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub notes: Option<String>,
}

/// Parameters for [`Client::add_member_to_conference`] (wire method `addMemberToConference`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct AddMemberToConferenceParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub member: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub conference: Option<i64>,
}

/// Parameters for [`Client::add_payment`] (wire method `addPayment`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct AddPaymentParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub client: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub payment: Option<f64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub test: Option<bool>,
}

/// Parameters for [`Client::assign_did_vpri`] (wire method `assignDIDvPRI`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct AssignDidVpriParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub vpri: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub did: Option<String>,
}

/// Parameters for [`Client::back_order_did_can`] (wire method `backOrderDIDCAN`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct BackOrderDidCanParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub quantity: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub province: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ratecenter: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub routing: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub failover_busy: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub failover_unreachable: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub failover_noanswer: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub voicemail: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pop: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub dialtime: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cnam: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub callerid_prefix: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub note: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub billing_type: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub test: Option<bool>,
}

/// Parameters for [`Client::back_order_did_usa`] (wire method `backOrderDIDUSA`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct BackOrderDidUsaParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub quantity: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub state: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ratecenter: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub routing: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub failover_busy: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub failover_unreachable: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub failover_noanswer: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub voicemail: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pop: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub dialtime: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cnam: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub callerid_prefix: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub note: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub billing_type: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub test: Option<bool>,
}

/// Parameters for [`Client::cancel_did`] (wire method `cancelDID`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct CancelDidParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub did: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cancelcomment: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub portout: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub test: Option<bool>,
}

/// Parameters for [`Client::cancel_fax_number`] (wire method `cancelFaxNumber`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct CancelFaxNumberParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub id: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub test: Option<i64>,
}

/// Parameters for [`Client::connect_did`] (wire method `connectDID`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct ConnectDidParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub did: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub account: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub monthly: Option<f64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub setup: Option<f64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub minute: Option<f64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_billing: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub dont_charge_setup: Option<f64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub dont_charge_monthly: Option<f64>,
}

/// Parameters for [`Client::connect_fax`] (wire method `connectFAX`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct ConnectFaxParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub did: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub account: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub monthly: Option<f64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub setup: Option<f64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub minute: Option<f64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_billing: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub dont_charge_setup: Option<f64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub dont_charge_monthly: Option<f64>,
}

/// Parameters for [`Client::create_sub_account`] (wire method `createSubAccount`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct CreateSubAccountParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub username: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub protocol: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub auth_type: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub password: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ip: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub device_type: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub callerid_number: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub canada_routing: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lock_international: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub international_route: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub music_on_hold: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub language: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub allowed_codecs: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub dtmf_mode: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub nat: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sip_traffic: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_expiry: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub rtp_timeout: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub rtp_hold_timeout: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ip_restriction: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub enable_ip_restriction: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pop_restriction: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub enable_pop_restriction: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub internal_extension: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub internal_voicemail: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub internal_dialtime: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub reseller_client: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub reseller_package: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub reseller_nextbilling: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub reseller_chargesetup: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub send_bye: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub record_calls: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub transcribe: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub transcription_locale: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub transcription_email: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub transcription_start_delay: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub enable_internal_cnam: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub internal_cnam: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub dialing_mode: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tfcarrier: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub internal_extension_location: Option<i64>,
}

/// Parameters for [`Client::create_voicemail`] (wire method `createVoicemail`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct CreateVoicemailParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub digits: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub password: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub skip_password: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub email: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub attach_message: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub delete_message: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub say_time: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub timezone: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub say_callerid: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub play_instructions: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub language: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub email_attachment_format: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub unavailable_message_recording: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub transcription: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub transcription_locale: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub transcription_redaction: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub transcription_sentiment: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub transcription_summary: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub transcription_format: Option<String>,
}

/// Parameters for [`Client::del_call_hunting`] (wire method `delCallHunting`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct DelCallHuntingParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub callhunting: Option<i64>,
}

/// Parameters for [`Client::del_call_parking`] (wire method `delCallParking`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct DelCallParkingParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub callparking: Option<i64>,
}

/// Parameters for [`Client::del_call_recording`] (wire method `delCallRecording`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct DelCallRecordingParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub callrecording: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub account: Option<String>,
}

/// Parameters for [`Client::del_callback`] (wire method `delCallback`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct DelCallbackParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub callback: Option<i64>,
}

/// Parameters for [`Client::del_caller_id_filtering`] (wire method `delCallerIDFiltering`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct DelCallerIdFilteringParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub filtering: Option<i64>,
}

/// Parameters for [`Client::del_client`] (wire method `delClient`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct DelClientParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub client: Option<i64>,
}

/// Parameters for [`Client::del_conference`] (wire method `delConference`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct DelConferenceParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub conference: Option<i64>,
}

/// Parameters for [`Client::del_conference_member`] (wire method `delConferenceMember`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct DelConferenceMemberParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub member: Option<i64>,
}

/// Parameters for [`Client::del_disa`] (wire method `delDISA`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct DelDisaParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub disa: Option<i64>,
}

/// Parameters for [`Client::del_email_to_fax`] (wire method `delEmailToFax`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct DelEmailToFaxParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub id: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub test: Option<i64>,
}

/// Parameters for [`Client::del_fax_folder`] (wire method `delFaxFolder`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct DelFaxFolderParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub id: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub test: Option<i64>,
}

/// Parameters for [`Client::del_forwarding`] (wire method `delForwarding`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct DelForwardingParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub forwarding: Option<i64>,
}

/// Parameters for [`Client::del_ivr`] (wire method `delIVR`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct DelIvrParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ivr: Option<i64>,
}

/// Parameters for [`Client::del_location`] (wire method `delLocation`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct DelLocationParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub id: Option<String>,
}

/// Parameters for [`Client::del_member_from_conference`] (wire method `delMemberFromConference`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct DelMemberFromConferenceParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub member: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub conference: Option<i64>,
}

/// Parameters for [`Client::del_messages`] (wire method `delMessages`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct DelMessagesParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub mailbox: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub folder: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub message_num: Option<i64>,
}

/// Parameters for [`Client::del_music_on_hold`] (wire method `delMusicOnHold`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct DelMusicOnHoldParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub music_on_hold: Option<String>,
}

/// Parameters for [`Client::del_phonebook`] (wire method `delPhonebook`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct DelPhonebookParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub phonebook: Option<i64>,
}

/// Parameters for [`Client::del_phonebook_group`] (wire method `delPhonebookGroup`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct DelPhonebookGroupParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub group: Option<String>,
}

/// Parameters for [`Client::del_queue`] (wire method `delQueue`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct DelQueueParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub queue: Option<i64>,
}

/// Parameters for [`Client::del_recording`] (wire method `delRecording`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct DelRecordingParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub recording: Option<i64>,
}

/// Parameters for [`Client::del_ring_group`] (wire method `delRingGroup`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct DelRingGroupParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ringgroup: Option<i64>,
}

/// Parameters for [`Client::del_sip_uri`] (wire method `delSIPURI`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct DelSipUriParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sipuri: Option<i64>,
}

/// Parameters for [`Client::del_static_member`] (wire method `delStaticMember`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct DelStaticMemberParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub member: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub queue: Option<i64>,
}

/// Parameters for [`Client::del_sub_account`] (wire method `delSubAccount`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct DelSubAccountParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub id: Option<i64>,
}

/// Parameters for [`Client::del_time_condition`] (wire method `delTimeCondition`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct DelTimeConditionParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub timecondition: Option<i64>,
}

/// Parameters for [`Client::del_voicemail`] (wire method `delVoicemail`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct DelVoicemailParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub mailbox: Option<i64>,
}

/// Parameters for [`Client::delete_fax_message`] (wire method `deleteFaxMessage`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct DeleteFaxMessageParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub id: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub test: Option<i64>,
}

/// Parameters for [`Client::delete_mms`] (wire method `deleteMMS`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct DeleteMmsParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub id: Option<i64>,
}

/// Parameters for [`Client::delete_sms`] (wire method `deleteSMS`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct DeleteSmsParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub id: Option<i64>,
}

/// Parameters for [`Client::e911_address_types`] (wire method `e911AddressTypes`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct E911AddressTypesParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub r#type: Option<String>,
}

/// Parameters for [`Client::e911_cancel`] (wire method `e911Cancel`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct E911CancelParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub did: Option<String>,
}

/// Parameters for [`Client::e911_info`] (wire method `e911Info`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct E911InfoParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub did: Option<String>,
}

/// Parameters for [`Client::e911_provision`] (wire method `e911Provision`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct E911ProvisionParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub did: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub full_name: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub street_number: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub street_name: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub address_type: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub address_number: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub city: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub state: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub country: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub zip: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub language: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub other_info: Option<String>,
}

/// Parameters for [`Client::e911_provision_manually`] (wire method `e911ProvisionManually`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct E911ProvisionManuallyParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub did: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub full_name: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub street_number: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub street_name: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub address_type: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub address_number: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub city: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub state: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub country: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub zip: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub language: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub other_info: Option<String>,
}

/// Parameters for [`Client::e911_update`] (wire method `e911Update`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct E911UpdateParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub did: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub full_name: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub street_number: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub street_name: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub address_type: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub address_number: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub city: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub state: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub country: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub zip: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub language: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub other_info: Option<String>,
}

/// Parameters for [`Client::e911_validate`] (wire method `e911Validate`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct E911ValidateParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub did: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub full_name: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub street_number: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub street_name: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub address_type: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub address_number: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub city: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub state: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub country: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub zip: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub language: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub other_info: Option<String>,
}

/// Parameters for [`Client::get_allowed_codecs`] (wire method `getAllowedCodecs`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetAllowedCodecsParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub codec: Option<String>,
}

/// Parameters for [`Client::get_auth_types`] (wire method `getAuthTypes`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetAuthTypesParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub r#type: Option<String>,
}

/// Parameters for [`Client::get_back_orders`] (wire method `getBackOrders`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetBackOrdersParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub id: Option<String>,
}

/// Parameters for [`Client::get_balance`] (wire method `getBalance`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetBalanceParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub advanced: Option<bool>,
}

/// Parameters for [`Client::get_balance_management`] (wire method `getBalanceManagement`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetBalanceManagementParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub balance_management: Option<String>,
}

/// Parameters for [`Client::get_cdr`] (wire method `getCDR`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetCdrParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub date_from: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub date_to: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub answered: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub noanswer: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub busy: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub failed: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub timezone: Option<f64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub calltype: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub callbilling: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub account: Option<String>,
}

/// Parameters for [`Client::get_call_accounts`] (wire method `getCallAccounts`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetCallAccountsParams {}

/// Parameters for [`Client::get_call_billing`] (wire method `getCallBilling`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetCallBillingParams {}

/// Parameters for [`Client::get_call_huntings`] (wire method `getCallHuntings`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetCallHuntingsParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub callhunting: Option<i64>,
}

/// Parameters for [`Client::get_call_parking`] (wire method `getCallParking`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetCallParkingParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub callparking: Option<i64>,
}

/// Parameters for [`Client::get_call_recording`] (wire method `getCallRecording`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetCallRecordingParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub callrecording: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub account: Option<String>,
}

/// Parameters for [`Client::get_call_recordings`] (wire method `getCallRecordings`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetCallRecordingsParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub account: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub start: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub length: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub date_from: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub date_to: Option<String>,
}

/// Parameters for [`Client::get_call_transcriptions`] (wire method `getCallTranscriptions`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetCallTranscriptionsParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub account: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub date_to: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub date_from: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub call_type: Option<String>,
}

/// Parameters for [`Client::get_call_types`] (wire method `getCallTypes`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetCallTypesParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub client: Option<String>,
}

/// Parameters for [`Client::get_callbacks`] (wire method `getCallbacks`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetCallbacksParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub callback: Option<String>,
}

/// Parameters for [`Client::get_caller_id_filtering`] (wire method `getCallerIDFiltering`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetCallerIdFilteringParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub filtering: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub did: Option<String>,
}

/// Parameters for [`Client::get_carriers`] (wire method `getCarriers`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetCarriersParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub carrier: Option<String>,
}

/// Parameters for [`Client::get_charges`] (wire method `getCharges`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetChargesParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub client: Option<String>,
}

/// Parameters for [`Client::get_client_packages`] (wire method `getClientPackages`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetClientPackagesParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub client: Option<String>,
}

/// Parameters for [`Client::get_client_threshold`] (wire method `getClientThreshold`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetClientThresholdParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub client: Option<String>,
}

/// Parameters for [`Client::get_clients`] (wire method `getClients`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetClientsParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub client: Option<String>,
}

/// Parameters for [`Client::get_conference`] (wire method `getConference`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetConferenceParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub conference: Option<i64>,
}

/// Parameters for [`Client::get_conference_members`] (wire method `getConferenceMembers`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetConferenceMembersParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub member: Option<i64>,
}

/// Parameters for [`Client::get_conference_recording_file`] (wire method `getConferenceRecordingFile`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetConferenceRecordingFileParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub conference: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub recording: Option<i64>,
}

/// Parameters for [`Client::get_conference_recordings`] (wire method `getConferenceRecordings`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetConferenceRecordingsParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub conference: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub date_from: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub date_to: Option<String>,
}

/// Parameters for [`Client::get_countries`] (wire method `getCountries`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetCountriesParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub country: Option<String>,
}

/// Parameters for [`Client::get_did_countries`] (wire method `getDIDCountries`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetDidCountriesParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub country_id: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub r#type: Option<String>,
}

/// Parameters for [`Client::get_dids_can`] (wire method `getDIDsCAN`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetDidsCanParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub province: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ratecenter: Option<String>,
}

/// Parameters for [`Client::get_dids_info`] (wire method `getDIDsInfo`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetDidsInfoParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub client: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub did: Option<String>,
}

/// Parameters for [`Client::get_dids_international_geographic`] (wire method `getDIDsInternationalGeographic`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetDidsInternationalGeographicParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub country_id: Option<String>,
}

/// Parameters for [`Client::get_dids_international_national`] (wire method `getDIDsInternationalNational`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetDidsInternationalNationalParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub country_id: Option<String>,
}

/// Parameters for [`Client::get_dids_international_toll_free`] (wire method `getDIDsInternationalTollFree`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetDidsInternationalTollFreeParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub country_id: Option<String>,
}

/// Parameters for [`Client::get_dids_usa`] (wire method `getDIDsUSA`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetDidsUsaParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub state: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ratecenter: Option<String>,
}

/// Parameters for [`Client::get_did_vpri`] (wire method `getDIDvPRI`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetDidVpriParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub vpri: Option<String>,
}

/// Parameters for [`Client::get_disas`] (wire method `getDISAs`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetDisasParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub disa: Option<String>,
}

/// Parameters for [`Client::get_dtmf_modes`] (wire method `getDTMFModes`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetDtmfModesParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub dtmf_mode: Option<String>,
}

/// Parameters for [`Client::get_deposits`] (wire method `getDeposits`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetDepositsParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub client: Option<String>,
}

/// Parameters for [`Client::get_device_types`] (wire method `getDeviceTypes`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetDeviceTypesParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub device_type: Option<String>,
}

/// Parameters for [`Client::get_email_to_fax`] (wire method `getEmailToFax`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetEmailToFaxParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub id: Option<i64>,
}

/// Parameters for [`Client::get_fax_folders`] (wire method `getFaxFolders`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetFaxFoldersParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub id: Option<i64>,
}

/// Parameters for [`Client::get_fax_message_pdf`] (wire method `getFaxMessagePDF`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetFaxMessagePdfParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub id: Option<i64>,
}

/// Parameters for [`Client::get_fax_messages`] (wire method `getFaxMessages`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetFaxMessagesParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub from: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub to: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub folder: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub id: Option<i64>,
}

/// Parameters for [`Client::get_fax_numbers_info`] (wire method `getFaxNumbersInfo`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetFaxNumbersInfoParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub did: Option<i64>,
}

/// Parameters for [`Client::get_fax_numbers_portability`] (wire method `getFaxNumbersPortability`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetFaxNumbersPortabilityParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub did: Option<i64>,
}

/// Parameters for [`Client::get_fax_provinces`] (wire method `getFaxProvinces`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetFaxProvincesParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub province: Option<String>,
}

/// Parameters for [`Client::get_fax_rate_centers_can`] (wire method `getFaxRateCentersCAN`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetFaxRateCentersCanParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub province: Option<String>,
}

/// Parameters for [`Client::get_fax_rate_centers_usa`] (wire method `getFaxRateCentersUSA`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetFaxRateCentersUsaParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub state: Option<String>,
}

/// Parameters for [`Client::get_fax_states`] (wire method `getFaxStates`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetFaxStatesParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub state: Option<String>,
}

/// Parameters for [`Client::get_forwardings`] (wire method `getForwardings`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetForwardingsParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub forwarding: Option<String>,
}

/// Parameters for [`Client::get_ip`] (wire method `getIP`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetIpParams {}

/// Parameters for [`Client::get_ivrs`] (wire method `getIVRs`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetIvrsParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ivr: Option<String>,
}

/// Parameters for [`Client::get_international_types`] (wire method `getInternationalTypes`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetInternationalTypesParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub r#type: Option<String>,
}

/// Parameters for [`Client::get_join_when_empty_types`] (wire method `getJoinWhenEmptyTypes`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetJoinWhenEmptyTypesParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub r#type: Option<String>,
}

/// Parameters for [`Client::get_lnp_attach`] (wire method `getLNPAttach`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetLnpAttachParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub attachid: Option<i64>,
}

/// Parameters for [`Client::get_lnp_attach_list`] (wire method `getLNPAttachList`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetLnpAttachListParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub portid: Option<i64>,
}

/// Parameters for [`Client::get_lnp_details`] (wire method `getLNPDetails`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetLnpDetailsParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub portid: Option<i64>,
}

/// Parameters for [`Client::get_lnp_list`] (wire method `getLNPList`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetLnpListParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub portid: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub portStatus: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub startDate: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub endDate: Option<String>,
}

/// Parameters for [`Client::get_lnp_list_status`] (wire method `getLNPListStatus`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetLnpListStatusParams {}

/// Parameters for [`Client::get_lnp_notes`] (wire method `getLNPNotes`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetLnpNotesParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub portid: Option<i64>,
}

/// Parameters for [`Client::get_lnp_status`] (wire method `getLNPStatus`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetLnpStatusParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub portid: Option<i64>,
}

/// Parameters for [`Client::get_languages`] (wire method `getLanguages`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetLanguagesParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub language: Option<String>,
}

/// Parameters for [`Client::get_locales`] (wire method `getLocales`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetLocalesParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub locale: Option<String>,
}

/// Parameters for [`Client::get_locations`] (wire method `getLocations`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetLocationsParams {}

/// Parameters for [`Client::get_lock_international`] (wire method `getLockInternational`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetLockInternationalParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lock_international: Option<String>,
}

/// Parameters for [`Client::get_mms`] (wire method `getMMS`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetMmsParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub mms: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub from: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub to: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub r#type: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub did: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub contact: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub limit: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub timezone: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub all_messages: Option<i64>,
}

/// Parameters for [`Client::get_media_mms`] (wire method `getMediaMMS`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetMediaMmsParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub id: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub media_as_array: Option<i64>,
}

/// Parameters for [`Client::get_music_on_hold`] (wire method `getMusicOnHold`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetMusicOnHoldParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub music_on_hold: Option<String>,
}

/// Parameters for [`Client::get_nat`] (wire method `getNAT`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetNatParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub nat: Option<String>,
}

/// Parameters for [`Client::get_packages`] (wire method `getPackages`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetPackagesParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub package: Option<String>,
}

/// Parameters for [`Client::get_phonebook`] (wire method `getPhonebook`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetPhonebookParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub phonebook: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub group: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub group_name: Option<String>,
}

/// Parameters for [`Client::get_phonebook_groups`] (wire method `getPhonebookGroups`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetPhonebookGroupsParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub group: Option<String>,
}

/// Parameters for [`Client::get_play_instructions`] (wire method `getPlayInstructions`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetPlayInstructionsParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub play_instructions: Option<String>,
}

/// Parameters for [`Client::get_portability`] (wire method `getPortability`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetPortabilityParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub did: Option<String>,
}

/// Parameters for [`Client::get_protocols`] (wire method `getProtocols`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetProtocolsParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub protocol: Option<String>,
}

/// Parameters for [`Client::get_provinces`] (wire method `getProvinces`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetProvincesParams {}

/// Parameters for [`Client::get_queues`] (wire method `getQueues`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetQueuesParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub queue: Option<String>,
}

/// Parameters for [`Client::get_rate_centers_can`] (wire method `getRateCentersCAN`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetRateCentersCanParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub province: Option<String>,
}

/// Parameters for [`Client::get_rate_centers_usa`] (wire method `getRateCentersUSA`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetRateCentersUsaParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub state: Option<String>,
}

/// Parameters for [`Client::get_rates`] (wire method `getRates`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetRatesParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub package: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub query: Option<String>,
}

/// Parameters for [`Client::get_recording_file`] (wire method `getRecordingFile`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetRecordingFileParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub recording: Option<String>,
}

/// Parameters for [`Client::get_recordings`] (wire method `getRecordings`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetRecordingsParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub recording: Option<String>,
}

/// Parameters for [`Client::get_registration_status`] (wire method `getRegistrationStatus`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetRegistrationStatusParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub account: Option<String>,
}

/// Parameters for [`Client::get_report_estimated_hold_time`] (wire method `getReportEstimatedHoldTime`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetReportEstimatedHoldTimeParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub r#type: Option<String>,
}

/// Parameters for [`Client::get_reseller_balance`] (wire method `getResellerBalance`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetResellerBalanceParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub client: Option<String>,
}

/// Parameters for [`Client::get_reseller_cdr`] (wire method `getResellerCDR`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetResellerCdrParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub date_from: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub date_to: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub client: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub answered: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub noanswer: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub busy: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub failed: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub timezone: Option<f64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub calltype: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub callbilling: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub account: Option<String>,
}

/// Parameters for [`Client::get_reseller_mms`] (wire method `getResellerMMS`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetResellerMmsParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub mms: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub client: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub from: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub to: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub r#type: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub did: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub contact: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub limit: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub timezone: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub all_messages: Option<i64>,
}

/// Parameters for [`Client::get_reseller_sms`] (wire method `getResellerSMS`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetResellerSmsParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sms: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub client: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub from: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub to: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub r#type: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub did: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub contact: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub limit: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub timezone: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub all_messages: Option<i64>,
}

/// Parameters for [`Client::get_ring_groups`] (wire method `getRingGroups`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetRingGroupsParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ring_group: Option<String>,
}

/// Parameters for [`Client::get_ring_strategies`] (wire method `getRingStrategies`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetRingStrategiesParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub strategy: Option<String>,
}

/// Parameters for [`Client::get_routes`] (wire method `getRoutes`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetRoutesParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub route: Option<String>,
}

/// Parameters for [`Client::get_sip_uris`] (wire method `getSIPURIs`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetSipUrisParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sipuri: Option<String>,
}

/// Parameters for [`Client::get_sms`] (wire method `getSMS`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetSmsParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sms: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub from: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub to: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub r#type: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub did: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub contact: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub limit: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub timezone: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub all_messages: Option<i64>,
}

/// Parameters for [`Client::get_servers_info`] (wire method `getServersInfo`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetServersInfoParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub server_pop: Option<String>,
}

/// Parameters for [`Client::get_states`] (wire method `getStates`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetStatesParams {}

/// Parameters for [`Client::get_static_members`] (wire method `getStaticMembers`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetStaticMembersParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub queue: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub member: Option<String>,
}

/// Parameters for [`Client::get_sub_accounts`] (wire method `getSubAccounts`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetSubAccountsParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub account: Option<String>,
}

/// Parameters for [`Client::get_termination_rates`] (wire method `getTerminationRates`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetTerminationRatesParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub query: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub route: Option<i64>,
}

/// Parameters for [`Client::get_time_conditions`] (wire method `getTimeConditions`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetTimeConditionsParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub timecondition: Option<i64>,
}

/// Parameters for [`Client::get_timezones`] (wire method `getTimezones`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetTimezonesParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub timezone: Option<String>,
}

/// Parameters for [`Client::get_transaction_history`] (wire method `getTransactionHistory`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetTransactionHistoryParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub date_from: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub date_to: Option<String>,
}

/// Parameters for [`Client::get_vpris`] (wire method `getVPRIs`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetVprisParams {}

/// Parameters for [`Client::get_voicemail_attachment_formats`] (wire method `getVoicemailAttachmentFormats`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetVoicemailAttachmentFormatsParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub email_attachment_format: Option<String>,
}

/// Parameters for [`Client::get_voicemail_folders`] (wire method `getVoicemailFolders`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetVoicemailFoldersParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub folder: Option<String>,
}

/// Parameters for [`Client::get_voicemail_message_file`] (wire method `getVoicemailMessageFile`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetVoicemailMessageFileParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub mailbox: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub folder: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub message_num: Option<i64>,
}

/// Parameters for [`Client::get_voicemail_messages`] (wire method `getVoicemailMessages`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetVoicemailMessagesParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub mailbox: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub folder: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub date_from: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub date_to: Option<String>,
}

/// Parameters for [`Client::get_voicemail_setups`] (wire method `getVoicemailSetups`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetVoicemailSetupsParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub voicemailsetup: Option<String>,
}

/// Parameters for [`Client::get_voicemail_transcriptions`] (wire method `getVoicemailTranscriptions`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetVoicemailTranscriptionsParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub account: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub mailbox: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub date_to: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub date_from: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub folder: Option<String>,
}

/// Parameters for [`Client::get_voicemails`] (wire method `getVoicemails`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetVoicemailsParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub mailbox: Option<String>,
}

/// Parameters for [`Client::mail_fax_message_pdf`] (wire method `mailFaxMessagePDF`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct MailFaxMessagePdfParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub id: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub email: Option<String>,
}

/// Parameters for [`Client::mark_listened_voicemail_message`] (wire method `markListenedVoicemailMessage`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct MarkListenedVoicemailMessageParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub mailbox: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub folder: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub message_num: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub listened: Option<String>,
}

/// Parameters for [`Client::mark_urgent_voicemail_message`] (wire method `markUrgentVoicemailMessage`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct MarkUrgentVoicemailMessageParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub mailbox: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub folder: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub message_num: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub urgent: Option<String>,
}

/// Parameters for [`Client::move_fax_message`] (wire method `moveFaxMessage`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct MoveFaxMessageParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub fax_id: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub folder_id: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub test: Option<i64>,
}

/// Parameters for [`Client::move_folder_voicemail_message`] (wire method `moveFolderVoicemailMessage`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct MoveFolderVoicemailMessageParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub mailbox: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub folder: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub message_num: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub new_folder: Option<String>,
}

/// Parameters for [`Client::order_did`] (wire method `orderDID`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct OrderDidParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub did: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub routing: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub failover_busy: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub failover_unreachable: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub failover_noanswer: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub voicemail: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pop: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub dialtime: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cnam: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub callerid_prefix: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub note: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub billing_type: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub account: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub monthly: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub setup: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub minute: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub test: Option<bool>,
}

/// Parameters for [`Client::order_did_international_geographic`] (wire method `orderDIDInternationalGeographic`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct OrderDidInternationalGeographicParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub location_id: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub quantity: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub routing: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub failover_busy: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub failover_unreachable: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub failover_noanswer: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub voicemail: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pop: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub dialtime: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cnam: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub callerid_prefix: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub billing_type: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub note: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub account: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub monthly: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub setup: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub minute: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub test: Option<i64>,
}

/// Parameters for [`Client::order_did_international_national`] (wire method `orderDIDInternationalNational`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct OrderDidInternationalNationalParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub location_id: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub quantity: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub routing: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub failover_busy: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub failover_unreachable: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub failover_noanswer: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub voicemail: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pop: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub dialtime: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cnam: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub callerid_prefix: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub billing_type: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub note: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub account: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub monthly: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub setup: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub minute: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub test: Option<i64>,
}

/// Parameters for [`Client::order_did_international_toll_free`] (wire method `orderDIDInternationalTollFree`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct OrderDidInternationalTollFreeParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub location_id: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub quantity: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub routing: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub failover_busy: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub failover_unreachable: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub failover_noanswer: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub voicemail: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pop: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub dialtime: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cnam: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub callerid_prefix: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub note: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub account: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub monthly: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub setup: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub minute: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub test: Option<i64>,
}

/// Parameters for [`Client::order_did_virtual`] (wire method `orderDIDVirtual`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct OrderDidVirtualParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub digits: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub routing: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub failover_busy: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub failover_unreachable: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub failover_noanswer: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub voicemail: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pop: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub dialtime: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cnam: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub callerid_prefix: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub note: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub account: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub monthly: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub setup: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub minute: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub test: Option<i64>,
}

/// Parameters for [`Client::order_fax_number`] (wire method `orderFaxNumber`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct OrderFaxNumberParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub location: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub quantity: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub email: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub email_enable: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub email_attach_file: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub url_callback: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub url_callback_enable: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub url_callback_retry: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub test: Option<i64>,
}

/// Parameters for [`Client::order_toll_free`] (wire method `orderTollFree`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct OrderTollFreeParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub did: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub routing: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub failover_busy: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub failover_unreachable: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub failover_noanswer: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub voicemail: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pop: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub dialtime: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cnam: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub callerid_prefix: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub note: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub account: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub monthly: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub setup: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub minute: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub test: Option<bool>,
}

/// Parameters for [`Client::order_vanity`] (wire method `orderVanity`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct OrderVanityParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub did: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub routing: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub failover_busy: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub failover_unreachable: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub failover_noanswer: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub voicemail: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pop: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub dialtime: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cnam: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub callerid_prefix: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub note: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub carrier: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub account: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub monthly: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub setup: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub minute: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub test: Option<bool>,
}

/// Parameters for [`Client::remove_did_vpri`] (wire method `removeDIDvPRI`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct RemoveDidVpriParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub vpri: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub did: Option<String>,
}

/// Parameters for [`Client::search_dids_can`] (wire method `searchDIDsCAN`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct SearchDidsCanParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub province: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub r#type: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub query: Option<String>,
}

/// Parameters for [`Client::search_dids_usa`] (wire method `searchDIDsUSA`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct SearchDidsUsaParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub state: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub r#type: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub query: Option<String>,
}

/// Parameters for [`Client::search_fax_area_code_can`] (wire method `searchFaxAreaCodeCAN`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct SearchFaxAreaCodeCanParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub area_code: Option<i64>,
}

/// Parameters for [`Client::search_fax_area_code_usa`] (wire method `searchFaxAreaCodeUSA`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct SearchFaxAreaCodeUsaParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub area_code: Option<i64>,
}

/// Parameters for [`Client::search_toll_free_can_us`] (wire method `searchTollFreeCanUS`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct SearchTollFreeCanUsParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub r#type: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub query: Option<String>,
}

/// Parameters for [`Client::search_toll_free_usa`] (wire method `searchTollFreeUSA`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct SearchTollFreeUsaParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub r#type: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub query: Option<String>,
}

/// Parameters for [`Client::search_vanity`] (wire method `searchVanity`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct SearchVanityParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub r#type: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub query: Option<String>,
}

/// Parameters for [`Client::send_call_recording_email`] (wire method `sendCallRecordingEmail`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct SendCallRecordingEmailParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub callrecording: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub account: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub email: Option<String>,
}

/// Parameters for [`Client::send_fax_message`] (wire method `sendFaxMessage`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct SendFaxMessageParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub to_number: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub from_name: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub from_number: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub send_email_enabled: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub send_email: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub station_id: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub file: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub test: Option<i64>,
}

/// Parameters for [`Client::send_mms`] (wire method `sendMMS`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct SendMmsParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub did: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub dst: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub message: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub media1: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub media2: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub media3: Option<String>,
}

/// Parameters for [`Client::send_sms`] (wire method `sendSMS`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct SendSmsParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub did: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub dst: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub message: Option<String>,
}

/// Parameters for [`Client::send_voicemail_email`] (wire method `sendVoicemailEmail`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct SendVoicemailEmailParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub mailbox: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub folder: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub message_num: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub email_address: Option<String>,
}

/// Parameters for [`Client::set_call_hunting`] (wire method `setCallHunting`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct SetCallHuntingParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub callhunting: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub music: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub recording: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub language: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub order: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub members: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ring_time: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub press: Option<String>,
}

/// Parameters for [`Client::set_call_parking`] (wire method `setCallParking`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct SetCallParkingParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub callparking: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub timeout: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub music: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub failover: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub language: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub destination: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub delay: Option<i64>,
}

/// Parameters for [`Client::set_callback`] (wire method `setCallback`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct SetCallbackParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub callback: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub number: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub delay_before: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub response_timeout: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub digit_timeout: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub callerid_number: Option<String>,
}

/// Parameters for [`Client::set_caller_id_filtering`] (wire method `setCallerIDFiltering`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct SetCallerIdFilteringParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub filter: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub callerid: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub did: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub routing: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub failover_unreachable: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub failover_busy: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub failover_noanswer: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub note: Option<String>,
}

/// Parameters for [`Client::set_client`] (wire method `setClient`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct SetClientParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub client: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub email: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub password: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub company: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub firstname: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lastname: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub address: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub city: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub state: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub country: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub zip: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub phone_number: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub balance_management: Option<i64>,
}

/// Parameters for [`Client::set_client_threshold`] (wire method `setClientThreshold`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct SetClientThresholdParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub client: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub email: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub threshold: Option<i64>,
}

/// Parameters for [`Client::set_conference`] (wire method `setConference`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct SetConferenceParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub conference: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub members: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_members: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sound_join: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sound_leave: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sound_has_joined: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sound_has_left: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sound_kicked: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sound_muted: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sound_unmuted: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sound_only_person: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sound_only_one: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sound_there_are: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sound_other_in_party: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sound_place_into_conference: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sound_get_pin: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sound_invalid_pin: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sound_locked: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sound_locked_now: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sound_unlocked_now: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sound_error_menu: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sound_participants_muted: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sound_participants_unmuted: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub language: Option<String>,
}

/// Parameters for [`Client::set_conference_member`] (wire method `setConferenceMember`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct SetConferenceMemberParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub member: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub conference: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pin: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub announce_join_leave: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub admin: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub start_muted: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub announce_user_count: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub announce_only_user: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub moh_when_empty: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub quiet: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub announcement: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub drop_silence: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub talking_threshold: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub silence_threshold: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub talk_detection: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub jitter_buffer: Option<String>,
}

/// Parameters for [`Client::set_did_billing_type`] (wire method `setDIDBillingType`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct SetDidBillingTypeParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub did: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub billing_type: Option<i64>,
}

/// Parameters for [`Client::set_did_info`] (wire method `setDIDInfo`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct SetDidInfoParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub did: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub routing: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub failover_busy: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub failover_unreachable: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub failover_noanswer: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub voicemail: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pop: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub dialtime: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cnam: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub callerid_prefix: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub note: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub port_out_pin: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub billing_type: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub record_calls: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub transcribe: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub transcription_locale: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub transcription_email: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub transcription_start_delay: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub voicemail_threshold: Option<i64>,
}

/// Parameters for [`Client::set_did_pop`] (wire method `setDIDPOP`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct SetDidPopParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub did: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pop: Option<i64>,
}

/// Parameters for [`Client::set_did_routing`] (wire method `setDIDRouting`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct SetDidRoutingParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub did: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub routing: Option<String>,
}

/// Parameters for [`Client::set_did_voicemail`] (wire method `setDIDVoicemail`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct SetDidVoicemailParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub did: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub voicemail: Option<String>,
}

/// Parameters for [`Client::set_disa`] (wire method `setDISA`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct SetDisaParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub disa: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pin: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub digit_timeout: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub callerid_override: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub language: Option<String>,
}

/// Parameters for [`Client::set_email_to_fax`] (wire method `setEmailToFax`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct SetEmailToFaxParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub id: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub enabled: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub auth_email: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub from_number_id: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub security_code_enabled: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub security_code: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub test: Option<i64>,
}

/// Parameters for [`Client::set_fax_folder`] (wire method `setFaxFolder`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct SetFaxFolderParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub id: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub test: Option<i64>,
}

/// Parameters for [`Client::set_fax_number_email`] (wire method `setFaxNumberEmail`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct SetFaxNumberEmailParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub did: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub email: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub email_enable: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub email_attach_file: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub test: Option<i64>,
}

/// Parameters for [`Client::set_fax_number_info`] (wire method `setFaxNumberInfo`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct SetFaxNumberInfoParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub did: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub email: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub email_enable: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub email_attach_file: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub url_callback: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub url_callback_enable: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub url_callback_retry: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub test: Option<i64>,
}

/// Parameters for [`Client::set_fax_number_url_callback`] (wire method `setFaxNumberURLCallback`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct SetFaxNumberUrlCallbackParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub did: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub url_callback: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub url_callback_enable: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub url_callback_retry: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub test: Option<i64>,
}

/// Parameters for [`Client::set_forwarding`] (wire method `setForwarding`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct SetForwardingParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub forwarding: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub phone_number: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub callerid_override: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub dtmf_digits: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pause: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub diversion_header: Option<i64>,
}

/// Parameters for [`Client::set_ivr`] (wire method `setIVR`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct SetIvrParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ivr: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub recording: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub timeout: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub language: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub voicemailsetup: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub choices: Option<String>,
}

/// Parameters for [`Client::set_location`] (wire method `setLocation`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct SetLocationParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
}

/// Parameters for [`Client::set_music_on_hold`] (wire method `setMusicOnHold`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct SetMusicOnHoldParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub volume: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub recordings: Option<String>,
}

/// Parameters for [`Client::set_phonebook`] (wire method `setPhonebook`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct SetPhonebookParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub phonebook: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub speed_dial: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub number: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub callerid: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub note: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub group: Option<i64>,
}

/// Parameters for [`Client::set_phonebook_group`] (wire method `setPhonebookGroup`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct SetPhonebookGroupParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub phonebook: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub group: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub members: Option<String>,
}

/// Parameters for [`Client::set_queue`] (wire method `setQueue`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct SetQueueParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub queue: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub queue_name: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub queue_number: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub queue_language: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub queue_password: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub callerid_prefix: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub join_announcement: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub priority_weight: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub agent_announcement: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub report_hold_time_agent: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub member_delay: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub maximum_wait_time: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub maximum_callers: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub join_when_empty: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub leave_when_empty: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ring_strategy: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ring_inuse: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub agent_ring_timeout: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub retry_timer: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub wrapup_time: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub voice_announcement: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub frequency_announcement: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub announce_position_frecuency: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub announce_round_seconds: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub if_announce_position_enabled_report_estimated_hold_time: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub thankyou_for_your_patience: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub music_on_hold: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub fail_over_routing_timeout: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub fail_over_routing_full: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub fail_over_routing_join_empty: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub fail_over_routing_leave_empty: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub fail_over_routing_join_unavail: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub fail_over_routing_leave_unavail: Option<String>,
}

/// Parameters for [`Client::set_recording`] (wire method `setRecording`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct SetRecordingParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub recording: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub file: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
}

/// Parameters for [`Client::set_ring_group`] (wire method `setRingGroup`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct SetRingGroupParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ring_group: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub members: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub voicemail: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub caller_announcement: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub music_on_hold: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub language: Option<String>,
}

/// Parameters for [`Client::set_sip_uri`] (wire method `setSIPURI`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct SetSipUriParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sipuri: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub uri: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub callerid_override: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub callerid_e164: Option<i64>,
}

/// Parameters for [`Client::set_sms`] (wire method `setSMS`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct SetSmsParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub did: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub enable: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub email_enabled: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub email_address: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sms_forward_enable: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sms_forward: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub url_callback_enable: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub url_callback: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub url_callback_retry: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sms_sipaccount: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sms_sipaccount_enabled: Option<String>,
}

/// Parameters for [`Client::set_static_member`] (wire method `setStaticMember`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct SetStaticMemberParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub member: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub queue: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub member_name: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub account: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub priority: Option<i64>,
}

/// Parameters for [`Client::set_sub_account`] (wire method `setSubAccount`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct SetSubAccountParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub id: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub auth_type: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub password: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ip: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub device_type: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub callerid_number: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub canada_routing: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lock_international: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub international_route: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub music_on_hold: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub language: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub allowed_codecs: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub dtmf_mode: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub nat: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sip_traffic: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_expiry: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub rtp_timeout: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub rtp_hold_timeout: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ip_restriction: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub enable_ip_restriction: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pop_restriction: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub enable_pop_restriction: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub internal_extension: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub internal_voicemail: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub internal_dialtime: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub reseller_client: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub reseller_package: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub reseller_nextbilling: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub reseller_chargesetup: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub send_bye: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub record_calls: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub transcribe: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub transcription_locale: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub transcription_email: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub transcription_start_delay: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub dialing_mode: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tfcarrier: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub internal_extension_location: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub default_e911: Option<String>,
}

/// Parameters for [`Client::set_time_condition`] (wire method `setTimeCondition`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct SetTimeConditionParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub timecondition: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub routing_match: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub routing_nomatch: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub starthour: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub startminute: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub endhour: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub endminute: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub weekdaystart: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub weekdayend: Option<String>,
}

/// Parameters for [`Client::set_voicemail`] (wire method `setVoicemail`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct SetVoicemailParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub mailbox: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub password: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub skip_password: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub email: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub attach_message: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub delete_message: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub say_time: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub timezone: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub say_callerid: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub play_instructions: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub language: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub email_attachment_format: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub unavailable_message_recording: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub transcription: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub transcription_locale: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub transcription_redaction: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub transcription_sentiment: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub transcription_summary: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub transcription_format: Option<String>,
}

/// Parameters for [`Client::signup_client`] (wire method `signupClient`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct SignupClientParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub firstname: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lastname: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub company: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub address: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub city: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub state: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub country: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub zip: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub phone_number: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub email: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub confirm_email: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub password: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub confirm_password: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub activate: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub balance_management: Option<i64>,
}

/// Parameters for [`Client::unconnect_did`] (wire method `unconnectDID`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct UnconnectDidParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub did: Option<String>,
}

/// Parameters for [`Client::unconnect_fax`] (wire method `unconnectFAX`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct UnconnectFaxParams {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub did: Option<String>,
}

impl Client {
    /// Call the `addCharge` API method.
    pub async fn add_charge(&self, params: &AddChargeParams) -> Result<Value> {
        self.call("addCharge", params).await
    }

    /// Call the `addCharge` API method and deserialize the response body into `T`.
    pub async fn add_charge_typed<T>(&self, params: &AddChargeParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("addCharge", params).await
    }

    /// Call the `addLNPFile` API method.
    pub async fn add_lnp_file(&self, params: &AddLnpFileParams) -> Result<Value> {
        self.call("addLNPFile", params).await
    }

    /// Call the `addLNPFile` API method and deserialize the response body into `T`.
    pub async fn add_lnp_file_typed<T>(&self, params: &AddLnpFileParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("addLNPFile", params).await
    }

    /// Call the `addLNPPort` API method.
    pub async fn add_lnp_port(&self, params: &AddLnpPortParams) -> Result<Value> {
        self.call("addLNPPort", params).await
    }

    /// Call the `addLNPPort` API method and deserialize the response body into `T`.
    pub async fn add_lnp_port_typed<T>(&self, params: &AddLnpPortParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("addLNPPort", params).await
    }

    /// Call the `addMemberToConference` API method.
    pub async fn add_member_to_conference(
        &self,
        params: &AddMemberToConferenceParams,
    ) -> Result<Value> {
        self.call("addMemberToConference", params).await
    }

    /// Call the `addMemberToConference` API method and deserialize the response body into `T`.
    pub async fn add_member_to_conference_typed<T>(
        &self,
        params: &AddMemberToConferenceParams,
    ) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("addMemberToConference", params).await
    }

    /// Call the `addPayment` API method.
    pub async fn add_payment(&self, params: &AddPaymentParams) -> Result<Value> {
        self.call("addPayment", params).await
    }

    /// Call the `addPayment` API method and deserialize the response body into `T`.
    pub async fn add_payment_typed<T>(&self, params: &AddPaymentParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("addPayment", params).await
    }

    /// Call the `assignDIDvPRI` API method.
    pub async fn assign_did_vpri(&self, params: &AssignDidVpriParams) -> Result<Value> {
        self.call("assignDIDvPRI", params).await
    }

    /// Call the `assignDIDvPRI` API method and deserialize the response body into `T`.
    pub async fn assign_did_vpri_typed<T>(&self, params: &AssignDidVpriParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("assignDIDvPRI", params).await
    }

    /// Call the `backOrderDIDCAN` API method.
    pub async fn back_order_did_can(&self, params: &BackOrderDidCanParams) -> Result<Value> {
        self.call("backOrderDIDCAN", params).await
    }

    /// Call the `backOrderDIDCAN` API method and deserialize the response body into `T`.
    pub async fn back_order_did_can_typed<T>(&self, params: &BackOrderDidCanParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("backOrderDIDCAN", params).await
    }

    /// Call the `backOrderDIDUSA` API method.
    pub async fn back_order_did_usa(&self, params: &BackOrderDidUsaParams) -> Result<Value> {
        self.call("backOrderDIDUSA", params).await
    }

    /// Call the `backOrderDIDUSA` API method and deserialize the response body into `T`.
    pub async fn back_order_did_usa_typed<T>(&self, params: &BackOrderDidUsaParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("backOrderDIDUSA", params).await
    }

    /// Call the `cancelDID` API method.
    pub async fn cancel_did(&self, params: &CancelDidParams) -> Result<Value> {
        self.call("cancelDID", params).await
    }

    /// Call the `cancelDID` API method and deserialize the response body into `T`.
    pub async fn cancel_did_typed<T>(&self, params: &CancelDidParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("cancelDID", params).await
    }

    /// Call the `cancelFaxNumber` API method.
    pub async fn cancel_fax_number(&self, params: &CancelFaxNumberParams) -> Result<Value> {
        self.call("cancelFaxNumber", params).await
    }

    /// Call the `cancelFaxNumber` API method and deserialize the response body into `T`.
    pub async fn cancel_fax_number_typed<T>(&self, params: &CancelFaxNumberParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("cancelFaxNumber", params).await
    }

    /// Call the `connectDID` API method.
    pub async fn connect_did(&self, params: &ConnectDidParams) -> Result<Value> {
        self.call("connectDID", params).await
    }

    /// Call the `connectDID` API method and deserialize the response body into `T`.
    pub async fn connect_did_typed<T>(&self, params: &ConnectDidParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("connectDID", params).await
    }

    /// Call the `connectFAX` API method.
    pub async fn connect_fax(&self, params: &ConnectFaxParams) -> Result<Value> {
        self.call("connectFAX", params).await
    }

    /// Call the `connectFAX` API method and deserialize the response body into `T`.
    pub async fn connect_fax_typed<T>(&self, params: &ConnectFaxParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("connectFAX", params).await
    }

    /// Call the `createSubAccount` API method.
    pub async fn create_sub_account(&self, params: &CreateSubAccountParams) -> Result<Value> {
        self.call("createSubAccount", params).await
    }

    /// Call the `createSubAccount` API method and deserialize the response body into `T`.
    pub async fn create_sub_account_typed<T>(&self, params: &CreateSubAccountParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("createSubAccount", params).await
    }

    /// Call the `createVoicemail` API method.
    pub async fn create_voicemail(&self, params: &CreateVoicemailParams) -> Result<Value> {
        self.call("createVoicemail", params).await
    }

    /// Call the `createVoicemail` API method and deserialize the response body into `T`.
    pub async fn create_voicemail_typed<T>(&self, params: &CreateVoicemailParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("createVoicemail", params).await
    }

    /// Call the `delCallHunting` API method.
    pub async fn del_call_hunting(&self, params: &DelCallHuntingParams) -> Result<Value> {
        self.call("delCallHunting", params).await
    }

    /// Call the `delCallHunting` API method and deserialize the response body into `T`.
    pub async fn del_call_hunting_typed<T>(&self, params: &DelCallHuntingParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("delCallHunting", params).await
    }

    /// Call the `delCallParking` API method.
    pub async fn del_call_parking(&self, params: &DelCallParkingParams) -> Result<Value> {
        self.call("delCallParking", params).await
    }

    /// Call the `delCallParking` API method and deserialize the response body into `T`.
    pub async fn del_call_parking_typed<T>(&self, params: &DelCallParkingParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("delCallParking", params).await
    }

    /// Call the `delCallRecording` API method.
    pub async fn del_call_recording(&self, params: &DelCallRecordingParams) -> Result<Value> {
        self.call("delCallRecording", params).await
    }

    /// Call the `delCallRecording` API method and deserialize the response body into `T`.
    pub async fn del_call_recording_typed<T>(&self, params: &DelCallRecordingParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("delCallRecording", params).await
    }

    /// Call the `delCallback` API method.
    pub async fn del_callback(&self, params: &DelCallbackParams) -> Result<Value> {
        self.call("delCallback", params).await
    }

    /// Call the `delCallback` API method and deserialize the response body into `T`.
    pub async fn del_callback_typed<T>(&self, params: &DelCallbackParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("delCallback", params).await
    }

    /// Call the `delCallerIDFiltering` API method.
    pub async fn del_caller_id_filtering(
        &self,
        params: &DelCallerIdFilteringParams,
    ) -> Result<Value> {
        self.call("delCallerIDFiltering", params).await
    }

    /// Call the `delCallerIDFiltering` API method and deserialize the response body into `T`.
    pub async fn del_caller_id_filtering_typed<T>(
        &self,
        params: &DelCallerIdFilteringParams,
    ) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("delCallerIDFiltering", params).await
    }

    /// Call the `delClient` API method.
    pub async fn del_client(&self, params: &DelClientParams) -> Result<Value> {
        self.call("delClient", params).await
    }

    /// Call the `delClient` API method and deserialize the response body into `T`.
    pub async fn del_client_typed<T>(&self, params: &DelClientParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("delClient", params).await
    }

    /// Call the `delConference` API method.
    pub async fn del_conference(&self, params: &DelConferenceParams) -> Result<Value> {
        self.call("delConference", params).await
    }

    /// Call the `delConference` API method and deserialize the response body into `T`.
    pub async fn del_conference_typed<T>(&self, params: &DelConferenceParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("delConference", params).await
    }

    /// Call the `delConferenceMember` API method.
    pub async fn del_conference_member(&self, params: &DelConferenceMemberParams) -> Result<Value> {
        self.call("delConferenceMember", params).await
    }

    /// Call the `delConferenceMember` API method and deserialize the response body into `T`.
    pub async fn del_conference_member_typed<T>(
        &self,
        params: &DelConferenceMemberParams,
    ) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("delConferenceMember", params).await
    }

    /// Call the `delDISA` API method.
    pub async fn del_disa(&self, params: &DelDisaParams) -> Result<Value> {
        self.call("delDISA", params).await
    }

    /// Call the `delDISA` API method and deserialize the response body into `T`.
    pub async fn del_disa_typed<T>(&self, params: &DelDisaParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("delDISA", params).await
    }

    /// Call the `delEmailToFax` API method.
    pub async fn del_email_to_fax(&self, params: &DelEmailToFaxParams) -> Result<Value> {
        self.call("delEmailToFax", params).await
    }

    /// Call the `delEmailToFax` API method and deserialize the response body into `T`.
    pub async fn del_email_to_fax_typed<T>(&self, params: &DelEmailToFaxParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("delEmailToFax", params).await
    }

    /// Call the `delFaxFolder` API method.
    pub async fn del_fax_folder(&self, params: &DelFaxFolderParams) -> Result<Value> {
        self.call("delFaxFolder", params).await
    }

    /// Call the `delFaxFolder` API method and deserialize the response body into `T`.
    pub async fn del_fax_folder_typed<T>(&self, params: &DelFaxFolderParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("delFaxFolder", params).await
    }

    /// Call the `delForwarding` API method.
    pub async fn del_forwarding(&self, params: &DelForwardingParams) -> Result<Value> {
        self.call("delForwarding", params).await
    }

    /// Call the `delForwarding` API method and deserialize the response body into `T`.
    pub async fn del_forwarding_typed<T>(&self, params: &DelForwardingParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("delForwarding", params).await
    }

    /// Call the `delIVR` API method.
    pub async fn del_ivr(&self, params: &DelIvrParams) -> Result<Value> {
        self.call("delIVR", params).await
    }

    /// Call the `delIVR` API method and deserialize the response body into `T`.
    pub async fn del_ivr_typed<T>(&self, params: &DelIvrParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("delIVR", params).await
    }

    /// Call the `delLocation` API method.
    pub async fn del_location(&self, params: &DelLocationParams) -> Result<Value> {
        self.call("delLocation", params).await
    }

    /// Call the `delLocation` API method and deserialize the response body into `T`.
    pub async fn del_location_typed<T>(&self, params: &DelLocationParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("delLocation", params).await
    }

    /// Call the `delMemberFromConference` API method.
    pub async fn del_member_from_conference(
        &self,
        params: &DelMemberFromConferenceParams,
    ) -> Result<Value> {
        self.call("delMemberFromConference", params).await
    }

    /// Call the `delMemberFromConference` API method and deserialize the response body into `T`.
    pub async fn del_member_from_conference_typed<T>(
        &self,
        params: &DelMemberFromConferenceParams,
    ) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("delMemberFromConference", params).await
    }

    /// Call the `delMessages` API method.
    pub async fn del_messages(&self, params: &DelMessagesParams) -> Result<Value> {
        self.call("delMessages", params).await
    }

    /// Call the `delMessages` API method and deserialize the response body into `T`.
    pub async fn del_messages_typed<T>(&self, params: &DelMessagesParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("delMessages", params).await
    }

    /// Call the `delMusicOnHold` API method.
    pub async fn del_music_on_hold(&self, params: &DelMusicOnHoldParams) -> Result<Value> {
        self.call("delMusicOnHold", params).await
    }

    /// Call the `delMusicOnHold` API method and deserialize the response body into `T`.
    pub async fn del_music_on_hold_typed<T>(&self, params: &DelMusicOnHoldParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("delMusicOnHold", params).await
    }

    /// Call the `delPhonebook` API method.
    pub async fn del_phonebook(&self, params: &DelPhonebookParams) -> Result<Value> {
        self.call("delPhonebook", params).await
    }

    /// Call the `delPhonebook` API method and deserialize the response body into `T`.
    pub async fn del_phonebook_typed<T>(&self, params: &DelPhonebookParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("delPhonebook", params).await
    }

    /// Call the `delPhonebookGroup` API method.
    pub async fn del_phonebook_group(&self, params: &DelPhonebookGroupParams) -> Result<Value> {
        self.call("delPhonebookGroup", params).await
    }

    /// Call the `delPhonebookGroup` API method and deserialize the response body into `T`.
    pub async fn del_phonebook_group_typed<T>(&self, params: &DelPhonebookGroupParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("delPhonebookGroup", params).await
    }

    /// Call the `delQueue` API method.
    pub async fn del_queue(&self, params: &DelQueueParams) -> Result<Value> {
        self.call("delQueue", params).await
    }

    /// Call the `delQueue` API method and deserialize the response body into `T`.
    pub async fn del_queue_typed<T>(&self, params: &DelQueueParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("delQueue", params).await
    }

    /// Call the `delRecording` API method.
    pub async fn del_recording(&self, params: &DelRecordingParams) -> Result<Value> {
        self.call("delRecording", params).await
    }

    /// Call the `delRecording` API method and deserialize the response body into `T`.
    pub async fn del_recording_typed<T>(&self, params: &DelRecordingParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("delRecording", params).await
    }

    /// Call the `delRingGroup` API method.
    pub async fn del_ring_group(&self, params: &DelRingGroupParams) -> Result<Value> {
        self.call("delRingGroup", params).await
    }

    /// Call the `delRingGroup` API method and deserialize the response body into `T`.
    pub async fn del_ring_group_typed<T>(&self, params: &DelRingGroupParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("delRingGroup", params).await
    }

    /// Call the `delSIPURI` API method.
    pub async fn del_sip_uri(&self, params: &DelSipUriParams) -> Result<Value> {
        self.call("delSIPURI", params).await
    }

    /// Call the `delSIPURI` API method and deserialize the response body into `T`.
    pub async fn del_sip_uri_typed<T>(&self, params: &DelSipUriParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("delSIPURI", params).await
    }

    /// Call the `delStaticMember` API method.
    pub async fn del_static_member(&self, params: &DelStaticMemberParams) -> Result<Value> {
        self.call("delStaticMember", params).await
    }

    /// Call the `delStaticMember` API method and deserialize the response body into `T`.
    pub async fn del_static_member_typed<T>(&self, params: &DelStaticMemberParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("delStaticMember", params).await
    }

    /// Call the `delSubAccount` API method.
    pub async fn del_sub_account(&self, params: &DelSubAccountParams) -> Result<Value> {
        self.call("delSubAccount", params).await
    }

    /// Call the `delSubAccount` API method and deserialize the response body into `T`.
    pub async fn del_sub_account_typed<T>(&self, params: &DelSubAccountParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("delSubAccount", params).await
    }

    /// Call the `delTimeCondition` API method.
    pub async fn del_time_condition(&self, params: &DelTimeConditionParams) -> Result<Value> {
        self.call("delTimeCondition", params).await
    }

    /// Call the `delTimeCondition` API method and deserialize the response body into `T`.
    pub async fn del_time_condition_typed<T>(&self, params: &DelTimeConditionParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("delTimeCondition", params).await
    }

    /// Call the `delVoicemail` API method.
    pub async fn del_voicemail(&self, params: &DelVoicemailParams) -> Result<Value> {
        self.call("delVoicemail", params).await
    }

    /// Call the `delVoicemail` API method and deserialize the response body into `T`.
    pub async fn del_voicemail_typed<T>(&self, params: &DelVoicemailParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("delVoicemail", params).await
    }

    /// Call the `deleteFaxMessage` API method.
    pub async fn delete_fax_message(&self, params: &DeleteFaxMessageParams) -> Result<Value> {
        self.call("deleteFaxMessage", params).await
    }

    /// Call the `deleteFaxMessage` API method and deserialize the response body into `T`.
    pub async fn delete_fax_message_typed<T>(&self, params: &DeleteFaxMessageParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("deleteFaxMessage", params).await
    }

    /// Call the `deleteMMS` API method.
    pub async fn delete_mms(&self, params: &DeleteMmsParams) -> Result<Value> {
        self.call("deleteMMS", params).await
    }

    /// Call the `deleteMMS` API method and deserialize the response body into `T`.
    pub async fn delete_mms_typed<T>(&self, params: &DeleteMmsParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("deleteMMS", params).await
    }

    /// Call the `deleteSMS` API method.
    pub async fn delete_sms(&self, params: &DeleteSmsParams) -> Result<Value> {
        self.call("deleteSMS", params).await
    }

    /// Call the `deleteSMS` API method and deserialize the response body into `T`.
    pub async fn delete_sms_typed<T>(&self, params: &DeleteSmsParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("deleteSMS", params).await
    }

    /// Call the `e911AddressTypes` API method.
    pub async fn e911_address_types(&self, params: &E911AddressTypesParams) -> Result<Value> {
        self.call("e911AddressTypes", params).await
    }

    /// Call the `e911AddressTypes` API method and deserialize the response body into `T`.
    pub async fn e911_address_types_typed<T>(&self, params: &E911AddressTypesParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("e911AddressTypes", params).await
    }

    /// Call the `e911Cancel` API method.
    pub async fn e911_cancel(&self, params: &E911CancelParams) -> Result<Value> {
        self.call("e911Cancel", params).await
    }

    /// Call the `e911Cancel` API method and deserialize the response body into `T`.
    pub async fn e911_cancel_typed<T>(&self, params: &E911CancelParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("e911Cancel", params).await
    }

    /// Call the `e911Info` API method.
    pub async fn e911_info(&self, params: &E911InfoParams) -> Result<Value> {
        self.call("e911Info", params).await
    }

    /// Call the `e911Info` API method and deserialize the response body into `T`.
    pub async fn e911_info_typed<T>(&self, params: &E911InfoParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("e911Info", params).await
    }

    /// Call the `e911Provision` API method.
    pub async fn e911_provision(&self, params: &E911ProvisionParams) -> Result<Value> {
        self.call("e911Provision", params).await
    }

    /// Call the `e911Provision` API method and deserialize the response body into `T`.
    pub async fn e911_provision_typed<T>(&self, params: &E911ProvisionParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("e911Provision", params).await
    }

    /// Call the `e911ProvisionManually` API method.
    pub async fn e911_provision_manually(
        &self,
        params: &E911ProvisionManuallyParams,
    ) -> Result<Value> {
        self.call("e911ProvisionManually", params).await
    }

    /// Call the `e911ProvisionManually` API method and deserialize the response body into `T`.
    pub async fn e911_provision_manually_typed<T>(
        &self,
        params: &E911ProvisionManuallyParams,
    ) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("e911ProvisionManually", params).await
    }

    /// Call the `e911Update` API method.
    pub async fn e911_update(&self, params: &E911UpdateParams) -> Result<Value> {
        self.call("e911Update", params).await
    }

    /// Call the `e911Update` API method and deserialize the response body into `T`.
    pub async fn e911_update_typed<T>(&self, params: &E911UpdateParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("e911Update", params).await
    }

    /// Call the `e911Validate` API method.
    pub async fn e911_validate(&self, params: &E911ValidateParams) -> Result<Value> {
        self.call("e911Validate", params).await
    }

    /// Call the `e911Validate` API method and deserialize the response body into `T`.
    pub async fn e911_validate_typed<T>(&self, params: &E911ValidateParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("e911Validate", params).await
    }

    /// Call the `getAllowedCodecs` API method.
    pub async fn get_allowed_codecs(&self, params: &GetAllowedCodecsParams) -> Result<Value> {
        self.call("getAllowedCodecs", params).await
    }

    /// Call the `getAllowedCodecs` API method and deserialize the response body into `T`.
    pub async fn get_allowed_codecs_typed<T>(&self, params: &GetAllowedCodecsParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("getAllowedCodecs", params).await
    }

    /// Call the `getAuthTypes` API method.
    pub async fn get_auth_types(&self, params: &GetAuthTypesParams) -> Result<Value> {
        self.call("getAuthTypes", params).await
    }

    /// Call the `getAuthTypes` API method and deserialize the response body into `T`.
    pub async fn get_auth_types_typed<T>(&self, params: &GetAuthTypesParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("getAuthTypes", params).await
    }

    /// Call the `getBackOrders` API method.
    pub async fn get_back_orders(&self, params: &GetBackOrdersParams) -> Result<Value> {
        self.call("getBackOrders", params).await
    }

    /// Call the `getBackOrders` API method and deserialize the response body into `T`.
    pub async fn get_back_orders_typed<T>(&self, params: &GetBackOrdersParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("getBackOrders", params).await
    }

    /// Call the `getBalance` API method.
    pub async fn get_balance(&self, params: &GetBalanceParams) -> Result<Value> {
        self.call("getBalance", params).await
    }

    /// Call the `getBalance` API method and deserialize the response body into `T`.
    pub async fn get_balance_typed<T>(&self, params: &GetBalanceParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("getBalance", params).await
    }

    /// Call the `getBalanceManagement` API method.
    pub async fn get_balance_management(
        &self,
        params: &GetBalanceManagementParams,
    ) -> Result<Value> {
        self.call("getBalanceManagement", params).await
    }

    /// Call the `getBalanceManagement` API method and deserialize the response body into `T`.
    pub async fn get_balance_management_typed<T>(
        &self,
        params: &GetBalanceManagementParams,
    ) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("getBalanceManagement", params).await
    }

    /// Call the `getCDR` API method.
    pub async fn get_cdr(&self, params: &GetCdrParams) -> Result<Value> {
        self.call("getCDR", params).await
    }

    /// Call the `getCDR` API method and deserialize the response body into `T`.
    pub async fn get_cdr_typed<T>(&self, params: &GetCdrParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("getCDR", params).await
    }

    /// Call the `getCallAccounts` API method.
    pub async fn get_call_accounts(&self, params: &GetCallAccountsParams) -> Result<Value> {
        self.call("getCallAccounts", params).await
    }

    /// Call the `getCallAccounts` API method and deserialize the response body into `T`.
    pub async fn get_call_accounts_typed<T>(&self, params: &GetCallAccountsParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("getCallAccounts", params).await
    }

    /// Call the `getCallBilling` API method.
    pub async fn get_call_billing(&self, params: &GetCallBillingParams) -> Result<Value> {
        self.call("getCallBilling", params).await
    }

    /// Call the `getCallBilling` API method and deserialize the response body into `T`.
    pub async fn get_call_billing_typed<T>(&self, params: &GetCallBillingParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("getCallBilling", params).await
    }

    /// Call the `getCallHuntings` API method.
    pub async fn get_call_huntings(&self, params: &GetCallHuntingsParams) -> Result<Value> {
        self.call("getCallHuntings", params).await
    }

    /// Call the `getCallHuntings` API method and deserialize the response body into `T`.
    pub async fn get_call_huntings_typed<T>(&self, params: &GetCallHuntingsParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("getCallHuntings", params).await
    }

    /// Call the `getCallParking` API method.
    pub async fn get_call_parking(&self, params: &GetCallParkingParams) -> Result<Value> {
        self.call("getCallParking", params).await
    }

    /// Call the `getCallParking` API method and deserialize the response body into `T`.
    pub async fn get_call_parking_typed<T>(&self, params: &GetCallParkingParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("getCallParking", params).await
    }

    /// Call the `getCallRecording` API method.
    pub async fn get_call_recording(&self, params: &GetCallRecordingParams) -> Result<Value> {
        self.call("getCallRecording", params).await
    }

    /// Call the `getCallRecording` API method and deserialize the response body into `T`.
    pub async fn get_call_recording_typed<T>(&self, params: &GetCallRecordingParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("getCallRecording", params).await
    }

    /// Call the `getCallRecordings` API method.
    pub async fn get_call_recordings(&self, params: &GetCallRecordingsParams) -> Result<Value> {
        self.call("getCallRecordings", params).await
    }

    /// Call the `getCallRecordings` API method and deserialize the response body into `T`.
    pub async fn get_call_recordings_typed<T>(&self, params: &GetCallRecordingsParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("getCallRecordings", params).await
    }

    /// Call the `getCallTranscriptions` API method.
    pub async fn get_call_transcriptions(
        &self,
        params: &GetCallTranscriptionsParams,
    ) -> Result<Value> {
        self.call("getCallTranscriptions", params).await
    }

    /// Call the `getCallTranscriptions` API method and deserialize the response body into `T`.
    pub async fn get_call_transcriptions_typed<T>(
        &self,
        params: &GetCallTranscriptionsParams,
    ) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("getCallTranscriptions", params).await
    }

    /// Call the `getCallTypes` API method.
    pub async fn get_call_types(&self, params: &GetCallTypesParams) -> Result<Value> {
        self.call("getCallTypes", params).await
    }

    /// Call the `getCallTypes` API method and deserialize the response body into `T`.
    pub async fn get_call_types_typed<T>(&self, params: &GetCallTypesParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("getCallTypes", params).await
    }

    /// Call the `getCallbacks` API method.
    pub async fn get_callbacks(&self, params: &GetCallbacksParams) -> Result<Value> {
        self.call("getCallbacks", params).await
    }

    /// Call the `getCallbacks` API method and deserialize the response body into `T`.
    pub async fn get_callbacks_typed<T>(&self, params: &GetCallbacksParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("getCallbacks", params).await
    }

    /// Call the `getCallerIDFiltering` API method.
    pub async fn get_caller_id_filtering(
        &self,
        params: &GetCallerIdFilteringParams,
    ) -> Result<Value> {
        self.call("getCallerIDFiltering", params).await
    }

    /// Call the `getCallerIDFiltering` API method and deserialize the response body into `T`.
    pub async fn get_caller_id_filtering_typed<T>(
        &self,
        params: &GetCallerIdFilteringParams,
    ) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("getCallerIDFiltering", params).await
    }

    /// Call the `getCarriers` API method.
    pub async fn get_carriers(&self, params: &GetCarriersParams) -> Result<Value> {
        self.call("getCarriers", params).await
    }

    /// Call the `getCarriers` API method and deserialize the response body into `T`.
    pub async fn get_carriers_typed<T>(&self, params: &GetCarriersParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("getCarriers", params).await
    }

    /// Call the `getCharges` API method.
    pub async fn get_charges(&self, params: &GetChargesParams) -> Result<Value> {
        self.call("getCharges", params).await
    }

    /// Call the `getCharges` API method and deserialize the response body into `T`.
    pub async fn get_charges_typed<T>(&self, params: &GetChargesParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("getCharges", params).await
    }

    /// Call the `getClientPackages` API method.
    pub async fn get_client_packages(&self, params: &GetClientPackagesParams) -> Result<Value> {
        self.call("getClientPackages", params).await
    }

    /// Call the `getClientPackages` API method and deserialize the response body into `T`.
    pub async fn get_client_packages_typed<T>(&self, params: &GetClientPackagesParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("getClientPackages", params).await
    }

    /// Call the `getClientThreshold` API method.
    pub async fn get_client_threshold(&self, params: &GetClientThresholdParams) -> Result<Value> {
        self.call("getClientThreshold", params).await
    }

    /// Call the `getClientThreshold` API method and deserialize the response body into `T`.
    pub async fn get_client_threshold_typed<T>(
        &self,
        params: &GetClientThresholdParams,
    ) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("getClientThreshold", params).await
    }

    /// Call the `getClients` API method.
    pub async fn get_clients(&self, params: &GetClientsParams) -> Result<Value> {
        self.call("getClients", params).await
    }

    /// Call the `getClients` API method and deserialize the response body into `T`.
    pub async fn get_clients_typed<T>(&self, params: &GetClientsParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("getClients", params).await
    }

    /// Call the `getConference` API method.
    pub async fn get_conference(&self, params: &GetConferenceParams) -> Result<Value> {
        self.call("getConference", params).await
    }

    /// Call the `getConference` API method and deserialize the response body into `T`.
    pub async fn get_conference_typed<T>(&self, params: &GetConferenceParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("getConference", params).await
    }

    /// Call the `getConferenceMembers` API method.
    pub async fn get_conference_members(
        &self,
        params: &GetConferenceMembersParams,
    ) -> Result<Value> {
        self.call("getConferenceMembers", params).await
    }

    /// Call the `getConferenceMembers` API method and deserialize the response body into `T`.
    pub async fn get_conference_members_typed<T>(
        &self,
        params: &GetConferenceMembersParams,
    ) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("getConferenceMembers", params).await
    }

    /// Call the `getConferenceRecordingFile` API method.
    pub async fn get_conference_recording_file(
        &self,
        params: &GetConferenceRecordingFileParams,
    ) -> Result<Value> {
        self.call("getConferenceRecordingFile", params).await
    }

    /// Call the `getConferenceRecordingFile` API method and deserialize the response body into `T`.
    pub async fn get_conference_recording_file_typed<T>(
        &self,
        params: &GetConferenceRecordingFileParams,
    ) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("getConferenceRecordingFile", params).await
    }

    /// Call the `getConferenceRecordings` API method.
    pub async fn get_conference_recordings(
        &self,
        params: &GetConferenceRecordingsParams,
    ) -> Result<Value> {
        self.call("getConferenceRecordings", params).await
    }

    /// Call the `getConferenceRecordings` API method and deserialize the response body into `T`.
    pub async fn get_conference_recordings_typed<T>(
        &self,
        params: &GetConferenceRecordingsParams,
    ) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("getConferenceRecordings", params).await
    }

    /// Call the `getCountries` API method.
    pub async fn get_countries(&self, params: &GetCountriesParams) -> Result<Value> {
        self.call("getCountries", params).await
    }

    /// Call the `getCountries` API method and deserialize the response body into `T`.
    pub async fn get_countries_typed<T>(&self, params: &GetCountriesParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("getCountries", params).await
    }

    /// Call the `getDIDCountries` API method.
    pub async fn get_did_countries(&self, params: &GetDidCountriesParams) -> Result<Value> {
        self.call("getDIDCountries", params).await
    }

    /// Call the `getDIDCountries` API method and deserialize the response body into `T`.
    pub async fn get_did_countries_typed<T>(&self, params: &GetDidCountriesParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("getDIDCountries", params).await
    }

    /// Call the `getDIDsCAN` API method.
    pub async fn get_dids_can(&self, params: &GetDidsCanParams) -> Result<Value> {
        self.call("getDIDsCAN", params).await
    }

    /// Call the `getDIDsCAN` API method and deserialize the response body into `T`.
    pub async fn get_dids_can_typed<T>(&self, params: &GetDidsCanParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("getDIDsCAN", params).await
    }

    /// Call the `getDIDsInfo` API method.
    pub async fn get_dids_info(&self, params: &GetDidsInfoParams) -> Result<Value> {
        self.call("getDIDsInfo", params).await
    }

    /// Call the `getDIDsInfo` API method and deserialize the response body into `T`.
    pub async fn get_dids_info_typed<T>(&self, params: &GetDidsInfoParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("getDIDsInfo", params).await
    }

    /// Call the `getDIDsInternationalGeographic` API method.
    pub async fn get_dids_international_geographic(
        &self,
        params: &GetDidsInternationalGeographicParams,
    ) -> Result<Value> {
        self.call("getDIDsInternationalGeographic", params).await
    }

    /// Call the `getDIDsInternationalGeographic` API method and deserialize the response body into `T`.
    pub async fn get_dids_international_geographic_typed<T>(
        &self,
        params: &GetDidsInternationalGeographicParams,
    ) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("getDIDsInternationalGeographic", params)
            .await
    }

    /// Call the `getDIDsInternationalNational` API method.
    pub async fn get_dids_international_national(
        &self,
        params: &GetDidsInternationalNationalParams,
    ) -> Result<Value> {
        self.call("getDIDsInternationalNational", params).await
    }

    /// Call the `getDIDsInternationalNational` API method and deserialize the response body into `T`.
    pub async fn get_dids_international_national_typed<T>(
        &self,
        params: &GetDidsInternationalNationalParams,
    ) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("getDIDsInternationalNational", params)
            .await
    }

    /// Call the `getDIDsInternationalTollFree` API method.
    pub async fn get_dids_international_toll_free(
        &self,
        params: &GetDidsInternationalTollFreeParams,
    ) -> Result<Value> {
        self.call("getDIDsInternationalTollFree", params).await
    }

    /// Call the `getDIDsInternationalTollFree` API method and deserialize the response body into `T`.
    pub async fn get_dids_international_toll_free_typed<T>(
        &self,
        params: &GetDidsInternationalTollFreeParams,
    ) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("getDIDsInternationalTollFree", params)
            .await
    }

    /// Call the `getDIDsUSA` API method.
    pub async fn get_dids_usa(&self, params: &GetDidsUsaParams) -> Result<Value> {
        self.call("getDIDsUSA", params).await
    }

    /// Call the `getDIDsUSA` API method and deserialize the response body into `T`.
    pub async fn get_dids_usa_typed<T>(&self, params: &GetDidsUsaParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("getDIDsUSA", params).await
    }

    /// Call the `getDIDvPRI` API method.
    pub async fn get_did_vpri(&self, params: &GetDidVpriParams) -> Result<Value> {
        self.call("getDIDvPRI", params).await
    }

    /// Call the `getDIDvPRI` API method and deserialize the response body into `T`.
    pub async fn get_did_vpri_typed<T>(&self, params: &GetDidVpriParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("getDIDvPRI", params).await
    }

    /// Call the `getDISAs` API method.
    pub async fn get_disas(&self, params: &GetDisasParams) -> Result<Value> {
        self.call("getDISAs", params).await
    }

    /// Call the `getDISAs` API method and deserialize the response body into `T`.
    pub async fn get_disas_typed<T>(&self, params: &GetDisasParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("getDISAs", params).await
    }

    /// Call the `getDTMFModes` API method.
    pub async fn get_dtmf_modes(&self, params: &GetDtmfModesParams) -> Result<Value> {
        self.call("getDTMFModes", params).await
    }

    /// Call the `getDTMFModes` API method and deserialize the response body into `T`.
    pub async fn get_dtmf_modes_typed<T>(&self, params: &GetDtmfModesParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("getDTMFModes", params).await
    }

    /// Call the `getDeposits` API method.
    pub async fn get_deposits(&self, params: &GetDepositsParams) -> Result<Value> {
        self.call("getDeposits", params).await
    }

    /// Call the `getDeposits` API method and deserialize the response body into `T`.
    pub async fn get_deposits_typed<T>(&self, params: &GetDepositsParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("getDeposits", params).await
    }

    /// Call the `getDeviceTypes` API method.
    pub async fn get_device_types(&self, params: &GetDeviceTypesParams) -> Result<Value> {
        self.call("getDeviceTypes", params).await
    }

    /// Call the `getDeviceTypes` API method and deserialize the response body into `T`.
    pub async fn get_device_types_typed<T>(&self, params: &GetDeviceTypesParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("getDeviceTypes", params).await
    }

    /// Call the `getEmailToFax` API method.
    pub async fn get_email_to_fax(&self, params: &GetEmailToFaxParams) -> Result<Value> {
        self.call("getEmailToFax", params).await
    }

    /// Call the `getEmailToFax` API method and deserialize the response body into `T`.
    pub async fn get_email_to_fax_typed<T>(&self, params: &GetEmailToFaxParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("getEmailToFax", params).await
    }

    /// Call the `getFaxFolders` API method.
    pub async fn get_fax_folders(&self, params: &GetFaxFoldersParams) -> Result<Value> {
        self.call("getFaxFolders", params).await
    }

    /// Call the `getFaxFolders` API method and deserialize the response body into `T`.
    pub async fn get_fax_folders_typed<T>(&self, params: &GetFaxFoldersParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("getFaxFolders", params).await
    }

    /// Call the `getFaxMessagePDF` API method.
    pub async fn get_fax_message_pdf(&self, params: &GetFaxMessagePdfParams) -> Result<Value> {
        self.call("getFaxMessagePDF", params).await
    }

    /// Call the `getFaxMessagePDF` API method and deserialize the response body into `T`.
    pub async fn get_fax_message_pdf_typed<T>(&self, params: &GetFaxMessagePdfParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("getFaxMessagePDF", params).await
    }

    /// Call the `getFaxMessages` API method.
    pub async fn get_fax_messages(&self, params: &GetFaxMessagesParams) -> Result<Value> {
        self.call("getFaxMessages", params).await
    }

    /// Call the `getFaxMessages` API method and deserialize the response body into `T`.
    pub async fn get_fax_messages_typed<T>(&self, params: &GetFaxMessagesParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("getFaxMessages", params).await
    }

    /// Call the `getFaxNumbersInfo` API method.
    pub async fn get_fax_numbers_info(&self, params: &GetFaxNumbersInfoParams) -> Result<Value> {
        self.call("getFaxNumbersInfo", params).await
    }

    /// Call the `getFaxNumbersInfo` API method and deserialize the response body into `T`.
    pub async fn get_fax_numbers_info_typed<T>(&self, params: &GetFaxNumbersInfoParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("getFaxNumbersInfo", params).await
    }

    /// Call the `getFaxNumbersPortability` API method.
    pub async fn get_fax_numbers_portability(
        &self,
        params: &GetFaxNumbersPortabilityParams,
    ) -> Result<Value> {
        self.call("getFaxNumbersPortability", params).await
    }

    /// Call the `getFaxNumbersPortability` API method and deserialize the response body into `T`.
    pub async fn get_fax_numbers_portability_typed<T>(
        &self,
        params: &GetFaxNumbersPortabilityParams,
    ) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("getFaxNumbersPortability", params).await
    }

    /// Call the `getFaxProvinces` API method.
    pub async fn get_fax_provinces(&self, params: &GetFaxProvincesParams) -> Result<Value> {
        self.call("getFaxProvinces", params).await
    }

    /// Call the `getFaxProvinces` API method and deserialize the response body into `T`.
    pub async fn get_fax_provinces_typed<T>(&self, params: &GetFaxProvincesParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("getFaxProvinces", params).await
    }

    /// Call the `getFaxRateCentersCAN` API method.
    pub async fn get_fax_rate_centers_can(
        &self,
        params: &GetFaxRateCentersCanParams,
    ) -> Result<Value> {
        self.call("getFaxRateCentersCAN", params).await
    }

    /// Call the `getFaxRateCentersCAN` API method and deserialize the response body into `T`.
    pub async fn get_fax_rate_centers_can_typed<T>(
        &self,
        params: &GetFaxRateCentersCanParams,
    ) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("getFaxRateCentersCAN", params).await
    }

    /// Call the `getFaxRateCentersUSA` API method.
    pub async fn get_fax_rate_centers_usa(
        &self,
        params: &GetFaxRateCentersUsaParams,
    ) -> Result<Value> {
        self.call("getFaxRateCentersUSA", params).await
    }

    /// Call the `getFaxRateCentersUSA` API method and deserialize the response body into `T`.
    pub async fn get_fax_rate_centers_usa_typed<T>(
        &self,
        params: &GetFaxRateCentersUsaParams,
    ) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("getFaxRateCentersUSA", params).await
    }

    /// Call the `getFaxStates` API method.
    pub async fn get_fax_states(&self, params: &GetFaxStatesParams) -> Result<Value> {
        self.call("getFaxStates", params).await
    }

    /// Call the `getFaxStates` API method and deserialize the response body into `T`.
    pub async fn get_fax_states_typed<T>(&self, params: &GetFaxStatesParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("getFaxStates", params).await
    }

    /// Call the `getForwardings` API method.
    pub async fn get_forwardings(&self, params: &GetForwardingsParams) -> Result<Value> {
        self.call("getForwardings", params).await
    }

    /// Call the `getForwardings` API method and deserialize the response body into `T`.
    pub async fn get_forwardings_typed<T>(&self, params: &GetForwardingsParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("getForwardings", params).await
    }

    /// Call the `getIP` API method.
    pub async fn get_ip(&self, params: &GetIpParams) -> Result<Value> {
        self.call("getIP", params).await
    }

    /// Call the `getIP` API method and deserialize the response body into `T`.
    pub async fn get_ip_typed<T>(&self, params: &GetIpParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("getIP", params).await
    }

    /// Call the `getIVRs` API method.
    pub async fn get_ivrs(&self, params: &GetIvrsParams) -> Result<Value> {
        self.call("getIVRs", params).await
    }

    /// Call the `getIVRs` API method and deserialize the response body into `T`.
    pub async fn get_ivrs_typed<T>(&self, params: &GetIvrsParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("getIVRs", params).await
    }

    /// Call the `getInternationalTypes` API method.
    pub async fn get_international_types(
        &self,
        params: &GetInternationalTypesParams,
    ) -> Result<Value> {
        self.call("getInternationalTypes", params).await
    }

    /// Call the `getInternationalTypes` API method and deserialize the response body into `T`.
    pub async fn get_international_types_typed<T>(
        &self,
        params: &GetInternationalTypesParams,
    ) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("getInternationalTypes", params).await
    }

    /// Call the `getJoinWhenEmptyTypes` API method.
    pub async fn get_join_when_empty_types(
        &self,
        params: &GetJoinWhenEmptyTypesParams,
    ) -> Result<Value> {
        self.call("getJoinWhenEmptyTypes", params).await
    }

    /// Call the `getJoinWhenEmptyTypes` API method and deserialize the response body into `T`.
    pub async fn get_join_when_empty_types_typed<T>(
        &self,
        params: &GetJoinWhenEmptyTypesParams,
    ) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("getJoinWhenEmptyTypes", params).await
    }

    /// Call the `getLNPAttach` API method.
    pub async fn get_lnp_attach(&self, params: &GetLnpAttachParams) -> Result<Value> {
        self.call("getLNPAttach", params).await
    }

    /// Call the `getLNPAttach` API method and deserialize the response body into `T`.
    pub async fn get_lnp_attach_typed<T>(&self, params: &GetLnpAttachParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("getLNPAttach", params).await
    }

    /// Call the `getLNPAttachList` API method.
    pub async fn get_lnp_attach_list(&self, params: &GetLnpAttachListParams) -> Result<Value> {
        self.call("getLNPAttachList", params).await
    }

    /// Call the `getLNPAttachList` API method and deserialize the response body into `T`.
    pub async fn get_lnp_attach_list_typed<T>(&self, params: &GetLnpAttachListParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("getLNPAttachList", params).await
    }

    /// Call the `getLNPDetails` API method.
    pub async fn get_lnp_details(&self, params: &GetLnpDetailsParams) -> Result<Value> {
        self.call("getLNPDetails", params).await
    }

    /// Call the `getLNPDetails` API method and deserialize the response body into `T`.
    pub async fn get_lnp_details_typed<T>(&self, params: &GetLnpDetailsParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("getLNPDetails", params).await
    }

    /// Call the `getLNPList` API method.
    pub async fn get_lnp_list(&self, params: &GetLnpListParams) -> Result<Value> {
        self.call("getLNPList", params).await
    }

    /// Call the `getLNPList` API method and deserialize the response body into `T`.
    pub async fn get_lnp_list_typed<T>(&self, params: &GetLnpListParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("getLNPList", params).await
    }

    /// Call the `getLNPListStatus` API method.
    pub async fn get_lnp_list_status(&self, params: &GetLnpListStatusParams) -> Result<Value> {
        self.call("getLNPListStatus", params).await
    }

    /// Call the `getLNPListStatus` API method and deserialize the response body into `T`.
    pub async fn get_lnp_list_status_typed<T>(&self, params: &GetLnpListStatusParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("getLNPListStatus", params).await
    }

    /// Call the `getLNPNotes` API method.
    pub async fn get_lnp_notes(&self, params: &GetLnpNotesParams) -> Result<Value> {
        self.call("getLNPNotes", params).await
    }

    /// Call the `getLNPNotes` API method and deserialize the response body into `T`.
    pub async fn get_lnp_notes_typed<T>(&self, params: &GetLnpNotesParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("getLNPNotes", params).await
    }

    /// Call the `getLNPStatus` API method.
    pub async fn get_lnp_status(&self, params: &GetLnpStatusParams) -> Result<Value> {
        self.call("getLNPStatus", params).await
    }

    /// Call the `getLNPStatus` API method and deserialize the response body into `T`.
    pub async fn get_lnp_status_typed<T>(&self, params: &GetLnpStatusParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("getLNPStatus", params).await
    }

    /// Call the `getLanguages` API method.
    pub async fn get_languages(&self, params: &GetLanguagesParams) -> Result<Value> {
        self.call("getLanguages", params).await
    }

    /// Call the `getLanguages` API method and deserialize the response body into `T`.
    pub async fn get_languages_typed<T>(&self, params: &GetLanguagesParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("getLanguages", params).await
    }

    /// Call the `getLocales` API method.
    pub async fn get_locales(&self, params: &GetLocalesParams) -> Result<Value> {
        self.call("getLocales", params).await
    }

    /// Call the `getLocales` API method and deserialize the response body into `T`.
    pub async fn get_locales_typed<T>(&self, params: &GetLocalesParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("getLocales", params).await
    }

    /// Call the `getLocations` API method.
    pub async fn get_locations(&self, params: &GetLocationsParams) -> Result<Value> {
        self.call("getLocations", params).await
    }

    /// Call the `getLocations` API method and deserialize the response body into `T`.
    pub async fn get_locations_typed<T>(&self, params: &GetLocationsParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("getLocations", params).await
    }

    /// Call the `getLockInternational` API method.
    pub async fn get_lock_international(
        &self,
        params: &GetLockInternationalParams,
    ) -> Result<Value> {
        self.call("getLockInternational", params).await
    }

    /// Call the `getLockInternational` API method and deserialize the response body into `T`.
    pub async fn get_lock_international_typed<T>(
        &self,
        params: &GetLockInternationalParams,
    ) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("getLockInternational", params).await
    }

    /// Call the `getMMS` API method.
    pub async fn get_mms(&self, params: &GetMmsParams) -> Result<Value> {
        self.call("getMMS", params).await
    }

    /// Call the `getMMS` API method and deserialize the response body into `T`.
    pub async fn get_mms_typed<T>(&self, params: &GetMmsParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("getMMS", params).await
    }

    /// Call the `getMediaMMS` API method.
    pub async fn get_media_mms(&self, params: &GetMediaMmsParams) -> Result<Value> {
        self.call("getMediaMMS", params).await
    }

    /// Call the `getMediaMMS` API method and deserialize the response body into `T`.
    pub async fn get_media_mms_typed<T>(&self, params: &GetMediaMmsParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("getMediaMMS", params).await
    }

    /// Call the `getMusicOnHold` API method.
    pub async fn get_music_on_hold(&self, params: &GetMusicOnHoldParams) -> Result<Value> {
        self.call("getMusicOnHold", params).await
    }

    /// Call the `getMusicOnHold` API method and deserialize the response body into `T`.
    pub async fn get_music_on_hold_typed<T>(&self, params: &GetMusicOnHoldParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("getMusicOnHold", params).await
    }

    /// Call the `getNAT` API method.
    pub async fn get_nat(&self, params: &GetNatParams) -> Result<Value> {
        self.call("getNAT", params).await
    }

    /// Call the `getNAT` API method and deserialize the response body into `T`.
    pub async fn get_nat_typed<T>(&self, params: &GetNatParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("getNAT", params).await
    }

    /// Call the `getPackages` API method.
    pub async fn get_packages(&self, params: &GetPackagesParams) -> Result<Value> {
        self.call("getPackages", params).await
    }

    /// Call the `getPackages` API method and deserialize the response body into `T`.
    pub async fn get_packages_typed<T>(&self, params: &GetPackagesParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("getPackages", params).await
    }

    /// Call the `getPhonebook` API method.
    pub async fn get_phonebook(&self, params: &GetPhonebookParams) -> Result<Value> {
        self.call("getPhonebook", params).await
    }

    /// Call the `getPhonebook` API method and deserialize the response body into `T`.
    pub async fn get_phonebook_typed<T>(&self, params: &GetPhonebookParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("getPhonebook", params).await
    }

    /// Call the `getPhonebookGroups` API method.
    pub async fn get_phonebook_groups(&self, params: &GetPhonebookGroupsParams) -> Result<Value> {
        self.call("getPhonebookGroups", params).await
    }

    /// Call the `getPhonebookGroups` API method and deserialize the response body into `T`.
    pub async fn get_phonebook_groups_typed<T>(
        &self,
        params: &GetPhonebookGroupsParams,
    ) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("getPhonebookGroups", params).await
    }

    /// Call the `getPlayInstructions` API method.
    pub async fn get_play_instructions(&self, params: &GetPlayInstructionsParams) -> Result<Value> {
        self.call("getPlayInstructions", params).await
    }

    /// Call the `getPlayInstructions` API method and deserialize the response body into `T`.
    pub async fn get_play_instructions_typed<T>(
        &self,
        params: &GetPlayInstructionsParams,
    ) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("getPlayInstructions", params).await
    }

    /// Call the `getPortability` API method.
    pub async fn get_portability(&self, params: &GetPortabilityParams) -> Result<Value> {
        self.call("getPortability", params).await
    }

    /// Call the `getPortability` API method and deserialize the response body into `T`.
    pub async fn get_portability_typed<T>(&self, params: &GetPortabilityParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("getPortability", params).await
    }

    /// Call the `getProtocols` API method.
    pub async fn get_protocols(&self, params: &GetProtocolsParams) -> Result<Value> {
        self.call("getProtocols", params).await
    }

    /// Call the `getProtocols` API method and deserialize the response body into `T`.
    pub async fn get_protocols_typed<T>(&self, params: &GetProtocolsParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("getProtocols", params).await
    }

    /// Call the `getProvinces` API method.
    pub async fn get_provinces(&self, params: &GetProvincesParams) -> Result<Value> {
        self.call("getProvinces", params).await
    }

    /// Call the `getProvinces` API method and deserialize the response body into `T`.
    pub async fn get_provinces_typed<T>(&self, params: &GetProvincesParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("getProvinces", params).await
    }

    /// Call the `getQueues` API method.
    pub async fn get_queues(&self, params: &GetQueuesParams) -> Result<Value> {
        self.call("getQueues", params).await
    }

    /// Call the `getQueues` API method and deserialize the response body into `T`.
    pub async fn get_queues_typed<T>(&self, params: &GetQueuesParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("getQueues", params).await
    }

    /// Call the `getRateCentersCAN` API method.
    pub async fn get_rate_centers_can(&self, params: &GetRateCentersCanParams) -> Result<Value> {
        self.call("getRateCentersCAN", params).await
    }

    /// Call the `getRateCentersCAN` API method and deserialize the response body into `T`.
    pub async fn get_rate_centers_can_typed<T>(&self, params: &GetRateCentersCanParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("getRateCentersCAN", params).await
    }

    /// Call the `getRateCentersUSA` API method.
    pub async fn get_rate_centers_usa(&self, params: &GetRateCentersUsaParams) -> Result<Value> {
        self.call("getRateCentersUSA", params).await
    }

    /// Call the `getRateCentersUSA` API method and deserialize the response body into `T`.
    pub async fn get_rate_centers_usa_typed<T>(&self, params: &GetRateCentersUsaParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("getRateCentersUSA", params).await
    }

    /// Call the `getRates` API method.
    pub async fn get_rates(&self, params: &GetRatesParams) -> Result<Value> {
        self.call("getRates", params).await
    }

    /// Call the `getRates` API method and deserialize the response body into `T`.
    pub async fn get_rates_typed<T>(&self, params: &GetRatesParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("getRates", params).await
    }

    /// Call the `getRecordingFile` API method.
    pub async fn get_recording_file(&self, params: &GetRecordingFileParams) -> Result<Value> {
        self.call("getRecordingFile", params).await
    }

    /// Call the `getRecordingFile` API method and deserialize the response body into `T`.
    pub async fn get_recording_file_typed<T>(&self, params: &GetRecordingFileParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("getRecordingFile", params).await
    }

    /// Call the `getRecordings` API method.
    pub async fn get_recordings(&self, params: &GetRecordingsParams) -> Result<Value> {
        self.call("getRecordings", params).await
    }

    /// Call the `getRecordings` API method and deserialize the response body into `T`.
    pub async fn get_recordings_typed<T>(&self, params: &GetRecordingsParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("getRecordings", params).await
    }

    /// Call the `getRegistrationStatus` API method.
    pub async fn get_registration_status(
        &self,
        params: &GetRegistrationStatusParams,
    ) -> Result<Value> {
        self.call("getRegistrationStatus", params).await
    }

    /// Call the `getRegistrationStatus` API method and deserialize the response body into `T`.
    pub async fn get_registration_status_typed<T>(
        &self,
        params: &GetRegistrationStatusParams,
    ) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("getRegistrationStatus", params).await
    }

    /// Call the `getReportEstimatedHoldTime` API method.
    pub async fn get_report_estimated_hold_time(
        &self,
        params: &GetReportEstimatedHoldTimeParams,
    ) -> Result<Value> {
        self.call("getReportEstimatedHoldTime", params).await
    }

    /// Call the `getReportEstimatedHoldTime` API method and deserialize the response body into `T`.
    pub async fn get_report_estimated_hold_time_typed<T>(
        &self,
        params: &GetReportEstimatedHoldTimeParams,
    ) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("getReportEstimatedHoldTime", params).await
    }

    /// Call the `getResellerBalance` API method.
    pub async fn get_reseller_balance(&self, params: &GetResellerBalanceParams) -> Result<Value> {
        self.call("getResellerBalance", params).await
    }

    /// Call the `getResellerBalance` API method and deserialize the response body into `T`.
    pub async fn get_reseller_balance_typed<T>(
        &self,
        params: &GetResellerBalanceParams,
    ) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("getResellerBalance", params).await
    }

    /// Call the `getResellerCDR` API method.
    pub async fn get_reseller_cdr(&self, params: &GetResellerCdrParams) -> Result<Value> {
        self.call("getResellerCDR", params).await
    }

    /// Call the `getResellerCDR` API method and deserialize the response body into `T`.
    pub async fn get_reseller_cdr_typed<T>(&self, params: &GetResellerCdrParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("getResellerCDR", params).await
    }

    /// Call the `getResellerMMS` API method.
    pub async fn get_reseller_mms(&self, params: &GetResellerMmsParams) -> Result<Value> {
        self.call("getResellerMMS", params).await
    }

    /// Call the `getResellerMMS` API method and deserialize the response body into `T`.
    pub async fn get_reseller_mms_typed<T>(&self, params: &GetResellerMmsParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("getResellerMMS", params).await
    }

    /// Call the `getResellerSMS` API method.
    pub async fn get_reseller_sms(&self, params: &GetResellerSmsParams) -> Result<Value> {
        self.call("getResellerSMS", params).await
    }

    /// Call the `getResellerSMS` API method and deserialize the response body into `T`.
    pub async fn get_reseller_sms_typed<T>(&self, params: &GetResellerSmsParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("getResellerSMS", params).await
    }

    /// Call the `getRingGroups` API method.
    pub async fn get_ring_groups(&self, params: &GetRingGroupsParams) -> Result<Value> {
        self.call("getRingGroups", params).await
    }

    /// Call the `getRingGroups` API method and deserialize the response body into `T`.
    pub async fn get_ring_groups_typed<T>(&self, params: &GetRingGroupsParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("getRingGroups", params).await
    }

    /// Call the `getRingStrategies` API method.
    pub async fn get_ring_strategies(&self, params: &GetRingStrategiesParams) -> Result<Value> {
        self.call("getRingStrategies", params).await
    }

    /// Call the `getRingStrategies` API method and deserialize the response body into `T`.
    pub async fn get_ring_strategies_typed<T>(&self, params: &GetRingStrategiesParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("getRingStrategies", params).await
    }

    /// Call the `getRoutes` API method.
    pub async fn get_routes(&self, params: &GetRoutesParams) -> Result<Value> {
        self.call("getRoutes", params).await
    }

    /// Call the `getRoutes` API method and deserialize the response body into `T`.
    pub async fn get_routes_typed<T>(&self, params: &GetRoutesParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("getRoutes", params).await
    }

    /// Call the `getSIPURIs` API method.
    pub async fn get_sip_uris(&self, params: &GetSipUrisParams) -> Result<Value> {
        self.call("getSIPURIs", params).await
    }

    /// Call the `getSIPURIs` API method and deserialize the response body into `T`.
    pub async fn get_sip_uris_typed<T>(&self, params: &GetSipUrisParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("getSIPURIs", params).await
    }

    /// Call the `getSMS` API method.
    pub async fn get_sms(&self, params: &GetSmsParams) -> Result<Value> {
        self.call("getSMS", params).await
    }

    /// Call the `getSMS` API method and deserialize the response body into `T`.
    pub async fn get_sms_typed<T>(&self, params: &GetSmsParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("getSMS", params).await
    }

    /// Call the `getServersInfo` API method.
    pub async fn get_servers_info(&self, params: &GetServersInfoParams) -> Result<Value> {
        self.call("getServersInfo", params).await
    }

    /// Call the `getServersInfo` API method and deserialize the response body into `T`.
    pub async fn get_servers_info_typed<T>(&self, params: &GetServersInfoParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("getServersInfo", params).await
    }

    /// Call the `getStates` API method.
    pub async fn get_states(&self, params: &GetStatesParams) -> Result<Value> {
        self.call("getStates", params).await
    }

    /// Call the `getStates` API method and deserialize the response body into `T`.
    pub async fn get_states_typed<T>(&self, params: &GetStatesParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("getStates", params).await
    }

    /// Call the `getStaticMembers` API method.
    pub async fn get_static_members(&self, params: &GetStaticMembersParams) -> Result<Value> {
        self.call("getStaticMembers", params).await
    }

    /// Call the `getStaticMembers` API method and deserialize the response body into `T`.
    pub async fn get_static_members_typed<T>(&self, params: &GetStaticMembersParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("getStaticMembers", params).await
    }

    /// Call the `getSubAccounts` API method.
    pub async fn get_sub_accounts(&self, params: &GetSubAccountsParams) -> Result<Value> {
        self.call("getSubAccounts", params).await
    }

    /// Call the `getSubAccounts` API method and deserialize the response body into `T`.
    pub async fn get_sub_accounts_typed<T>(&self, params: &GetSubAccountsParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("getSubAccounts", params).await
    }

    /// Call the `getTerminationRates` API method.
    pub async fn get_termination_rates(&self, params: &GetTerminationRatesParams) -> Result<Value> {
        self.call("getTerminationRates", params).await
    }

    /// Call the `getTerminationRates` API method and deserialize the response body into `T`.
    pub async fn get_termination_rates_typed<T>(
        &self,
        params: &GetTerminationRatesParams,
    ) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("getTerminationRates", params).await
    }

    /// Call the `getTimeConditions` API method.
    pub async fn get_time_conditions(&self, params: &GetTimeConditionsParams) -> Result<Value> {
        self.call("getTimeConditions", params).await
    }

    /// Call the `getTimeConditions` API method and deserialize the response body into `T`.
    pub async fn get_time_conditions_typed<T>(&self, params: &GetTimeConditionsParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("getTimeConditions", params).await
    }

    /// Call the `getTimezones` API method.
    pub async fn get_timezones(&self, params: &GetTimezonesParams) -> Result<Value> {
        self.call("getTimezones", params).await
    }

    /// Call the `getTimezones` API method and deserialize the response body into `T`.
    pub async fn get_timezones_typed<T>(&self, params: &GetTimezonesParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("getTimezones", params).await
    }

    /// Call the `getTransactionHistory` API method.
    pub async fn get_transaction_history(
        &self,
        params: &GetTransactionHistoryParams,
    ) -> Result<Value> {
        self.call("getTransactionHistory", params).await
    }

    /// Call the `getTransactionHistory` API method and deserialize the response body into `T`.
    pub async fn get_transaction_history_typed<T>(
        &self,
        params: &GetTransactionHistoryParams,
    ) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("getTransactionHistory", params).await
    }

    /// Call the `getVPRIs` API method.
    pub async fn get_vpris(&self, params: &GetVprisParams) -> Result<Value> {
        self.call("getVPRIs", params).await
    }

    /// Call the `getVPRIs` API method and deserialize the response body into `T`.
    pub async fn get_vpris_typed<T>(&self, params: &GetVprisParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("getVPRIs", params).await
    }

    /// Call the `getVoicemailAttachmentFormats` API method.
    pub async fn get_voicemail_attachment_formats(
        &self,
        params: &GetVoicemailAttachmentFormatsParams,
    ) -> Result<Value> {
        self.call("getVoicemailAttachmentFormats", params).await
    }

    /// Call the `getVoicemailAttachmentFormats` API method and deserialize the response body into `T`.
    pub async fn get_voicemail_attachment_formats_typed<T>(
        &self,
        params: &GetVoicemailAttachmentFormatsParams,
    ) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("getVoicemailAttachmentFormats", params)
            .await
    }

    /// Call the `getVoicemailFolders` API method.
    pub async fn get_voicemail_folders(&self, params: &GetVoicemailFoldersParams) -> Result<Value> {
        self.call("getVoicemailFolders", params).await
    }

    /// Call the `getVoicemailFolders` API method and deserialize the response body into `T`.
    pub async fn get_voicemail_folders_typed<T>(
        &self,
        params: &GetVoicemailFoldersParams,
    ) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("getVoicemailFolders", params).await
    }

    /// Call the `getVoicemailMessageFile` API method.
    pub async fn get_voicemail_message_file(
        &self,
        params: &GetVoicemailMessageFileParams,
    ) -> Result<Value> {
        self.call("getVoicemailMessageFile", params).await
    }

    /// Call the `getVoicemailMessageFile` API method and deserialize the response body into `T`.
    pub async fn get_voicemail_message_file_typed<T>(
        &self,
        params: &GetVoicemailMessageFileParams,
    ) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("getVoicemailMessageFile", params).await
    }

    /// Call the `getVoicemailMessages` API method.
    pub async fn get_voicemail_messages(
        &self,
        params: &GetVoicemailMessagesParams,
    ) -> Result<Value> {
        self.call("getVoicemailMessages", params).await
    }

    /// Call the `getVoicemailMessages` API method and deserialize the response body into `T`.
    pub async fn get_voicemail_messages_typed<T>(
        &self,
        params: &GetVoicemailMessagesParams,
    ) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("getVoicemailMessages", params).await
    }

    /// Call the `getVoicemailSetups` API method.
    pub async fn get_voicemail_setups(&self, params: &GetVoicemailSetupsParams) -> Result<Value> {
        self.call("getVoicemailSetups", params).await
    }

    /// Call the `getVoicemailSetups` API method and deserialize the response body into `T`.
    pub async fn get_voicemail_setups_typed<T>(
        &self,
        params: &GetVoicemailSetupsParams,
    ) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("getVoicemailSetups", params).await
    }

    /// Call the `getVoicemailTranscriptions` API method.
    pub async fn get_voicemail_transcriptions(
        &self,
        params: &GetVoicemailTranscriptionsParams,
    ) -> Result<Value> {
        self.call("getVoicemailTranscriptions", params).await
    }

    /// Call the `getVoicemailTranscriptions` API method and deserialize the response body into `T`.
    pub async fn get_voicemail_transcriptions_typed<T>(
        &self,
        params: &GetVoicemailTranscriptionsParams,
    ) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("getVoicemailTranscriptions", params).await
    }

    /// Call the `getVoicemails` API method.
    pub async fn get_voicemails(&self, params: &GetVoicemailsParams) -> Result<Value> {
        self.call("getVoicemails", params).await
    }

    /// Call the `getVoicemails` API method and deserialize the response body into `T`.
    pub async fn get_voicemails_typed<T>(&self, params: &GetVoicemailsParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("getVoicemails", params).await
    }

    /// Call the `mailFaxMessagePDF` API method.
    pub async fn mail_fax_message_pdf(&self, params: &MailFaxMessagePdfParams) -> Result<Value> {
        self.call("mailFaxMessagePDF", params).await
    }

    /// Call the `mailFaxMessagePDF` API method and deserialize the response body into `T`.
    pub async fn mail_fax_message_pdf_typed<T>(&self, params: &MailFaxMessagePdfParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("mailFaxMessagePDF", params).await
    }

    /// Call the `markListenedVoicemailMessage` API method.
    pub async fn mark_listened_voicemail_message(
        &self,
        params: &MarkListenedVoicemailMessageParams,
    ) -> Result<Value> {
        self.call("markListenedVoicemailMessage", params).await
    }

    /// Call the `markListenedVoicemailMessage` API method and deserialize the response body into `T`.
    pub async fn mark_listened_voicemail_message_typed<T>(
        &self,
        params: &MarkListenedVoicemailMessageParams,
    ) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("markListenedVoicemailMessage", params)
            .await
    }

    /// Call the `markUrgentVoicemailMessage` API method.
    pub async fn mark_urgent_voicemail_message(
        &self,
        params: &MarkUrgentVoicemailMessageParams,
    ) -> Result<Value> {
        self.call("markUrgentVoicemailMessage", params).await
    }

    /// Call the `markUrgentVoicemailMessage` API method and deserialize the response body into `T`.
    pub async fn mark_urgent_voicemail_message_typed<T>(
        &self,
        params: &MarkUrgentVoicemailMessageParams,
    ) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("markUrgentVoicemailMessage", params).await
    }

    /// Call the `moveFaxMessage` API method.
    pub async fn move_fax_message(&self, params: &MoveFaxMessageParams) -> Result<Value> {
        self.call("moveFaxMessage", params).await
    }

    /// Call the `moveFaxMessage` API method and deserialize the response body into `T`.
    pub async fn move_fax_message_typed<T>(&self, params: &MoveFaxMessageParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("moveFaxMessage", params).await
    }

    /// Call the `moveFolderVoicemailMessage` API method.
    pub async fn move_folder_voicemail_message(
        &self,
        params: &MoveFolderVoicemailMessageParams,
    ) -> Result<Value> {
        self.call("moveFolderVoicemailMessage", params).await
    }

    /// Call the `moveFolderVoicemailMessage` API method and deserialize the response body into `T`.
    pub async fn move_folder_voicemail_message_typed<T>(
        &self,
        params: &MoveFolderVoicemailMessageParams,
    ) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("moveFolderVoicemailMessage", params).await
    }

    /// Call the `orderDID` API method.
    pub async fn order_did(&self, params: &OrderDidParams) -> Result<Value> {
        self.call("orderDID", params).await
    }

    /// Call the `orderDID` API method and deserialize the response body into `T`.
    pub async fn order_did_typed<T>(&self, params: &OrderDidParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("orderDID", params).await
    }

    /// Call the `orderDIDInternationalGeographic` API method.
    pub async fn order_did_international_geographic(
        &self,
        params: &OrderDidInternationalGeographicParams,
    ) -> Result<Value> {
        self.call("orderDIDInternationalGeographic", params).await
    }

    /// Call the `orderDIDInternationalGeographic` API method and deserialize the response body into `T`.
    pub async fn order_did_international_geographic_typed<T>(
        &self,
        params: &OrderDidInternationalGeographicParams,
    ) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("orderDIDInternationalGeographic", params)
            .await
    }

    /// Call the `orderDIDInternationalNational` API method.
    pub async fn order_did_international_national(
        &self,
        params: &OrderDidInternationalNationalParams,
    ) -> Result<Value> {
        self.call("orderDIDInternationalNational", params).await
    }

    /// Call the `orderDIDInternationalNational` API method and deserialize the response body into `T`.
    pub async fn order_did_international_national_typed<T>(
        &self,
        params: &OrderDidInternationalNationalParams,
    ) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("orderDIDInternationalNational", params)
            .await
    }

    /// Call the `orderDIDInternationalTollFree` API method.
    pub async fn order_did_international_toll_free(
        &self,
        params: &OrderDidInternationalTollFreeParams,
    ) -> Result<Value> {
        self.call("orderDIDInternationalTollFree", params).await
    }

    /// Call the `orderDIDInternationalTollFree` API method and deserialize the response body into `T`.
    pub async fn order_did_international_toll_free_typed<T>(
        &self,
        params: &OrderDidInternationalTollFreeParams,
    ) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("orderDIDInternationalTollFree", params)
            .await
    }

    /// Call the `orderDIDVirtual` API method.
    pub async fn order_did_virtual(&self, params: &OrderDidVirtualParams) -> Result<Value> {
        self.call("orderDIDVirtual", params).await
    }

    /// Call the `orderDIDVirtual` API method and deserialize the response body into `T`.
    pub async fn order_did_virtual_typed<T>(&self, params: &OrderDidVirtualParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("orderDIDVirtual", params).await
    }

    /// Call the `orderFaxNumber` API method.
    pub async fn order_fax_number(&self, params: &OrderFaxNumberParams) -> Result<Value> {
        self.call("orderFaxNumber", params).await
    }

    /// Call the `orderFaxNumber` API method and deserialize the response body into `T`.
    pub async fn order_fax_number_typed<T>(&self, params: &OrderFaxNumberParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("orderFaxNumber", params).await
    }

    /// Call the `orderTollFree` API method.
    pub async fn order_toll_free(&self, params: &OrderTollFreeParams) -> Result<Value> {
        self.call("orderTollFree", params).await
    }

    /// Call the `orderTollFree` API method and deserialize the response body into `T`.
    pub async fn order_toll_free_typed<T>(&self, params: &OrderTollFreeParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("orderTollFree", params).await
    }

    /// Call the `orderVanity` API method.
    pub async fn order_vanity(&self, params: &OrderVanityParams) -> Result<Value> {
        self.call("orderVanity", params).await
    }

    /// Call the `orderVanity` API method and deserialize the response body into `T`.
    pub async fn order_vanity_typed<T>(&self, params: &OrderVanityParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("orderVanity", params).await
    }

    /// Call the `removeDIDvPRI` API method.
    pub async fn remove_did_vpri(&self, params: &RemoveDidVpriParams) -> Result<Value> {
        self.call("removeDIDvPRI", params).await
    }

    /// Call the `removeDIDvPRI` API method and deserialize the response body into `T`.
    pub async fn remove_did_vpri_typed<T>(&self, params: &RemoveDidVpriParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("removeDIDvPRI", params).await
    }

    /// Call the `searchDIDsCAN` API method.
    pub async fn search_dids_can(&self, params: &SearchDidsCanParams) -> Result<Value> {
        self.call("searchDIDsCAN", params).await
    }

    /// Call the `searchDIDsCAN` API method and deserialize the response body into `T`.
    pub async fn search_dids_can_typed<T>(&self, params: &SearchDidsCanParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("searchDIDsCAN", params).await
    }

    /// Call the `searchDIDsUSA` API method.
    pub async fn search_dids_usa(&self, params: &SearchDidsUsaParams) -> Result<Value> {
        self.call("searchDIDsUSA", params).await
    }

    /// Call the `searchDIDsUSA` API method and deserialize the response body into `T`.
    pub async fn search_dids_usa_typed<T>(&self, params: &SearchDidsUsaParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("searchDIDsUSA", params).await
    }

    /// Call the `searchFaxAreaCodeCAN` API method.
    pub async fn search_fax_area_code_can(
        &self,
        params: &SearchFaxAreaCodeCanParams,
    ) -> Result<Value> {
        self.call("searchFaxAreaCodeCAN", params).await
    }

    /// Call the `searchFaxAreaCodeCAN` API method and deserialize the response body into `T`.
    pub async fn search_fax_area_code_can_typed<T>(
        &self,
        params: &SearchFaxAreaCodeCanParams,
    ) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("searchFaxAreaCodeCAN", params).await
    }

    /// Call the `searchFaxAreaCodeUSA` API method.
    pub async fn search_fax_area_code_usa(
        &self,
        params: &SearchFaxAreaCodeUsaParams,
    ) -> Result<Value> {
        self.call("searchFaxAreaCodeUSA", params).await
    }

    /// Call the `searchFaxAreaCodeUSA` API method and deserialize the response body into `T`.
    pub async fn search_fax_area_code_usa_typed<T>(
        &self,
        params: &SearchFaxAreaCodeUsaParams,
    ) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("searchFaxAreaCodeUSA", params).await
    }

    /// Call the `searchTollFreeCanUS` API method.
    pub async fn search_toll_free_can_us(
        &self,
        params: &SearchTollFreeCanUsParams,
    ) -> Result<Value> {
        self.call("searchTollFreeCanUS", params).await
    }

    /// Call the `searchTollFreeCanUS` API method and deserialize the response body into `T`.
    pub async fn search_toll_free_can_us_typed<T>(
        &self,
        params: &SearchTollFreeCanUsParams,
    ) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("searchTollFreeCanUS", params).await
    }

    /// Call the `searchTollFreeUSA` API method.
    pub async fn search_toll_free_usa(&self, params: &SearchTollFreeUsaParams) -> Result<Value> {
        self.call("searchTollFreeUSA", params).await
    }

    /// Call the `searchTollFreeUSA` API method and deserialize the response body into `T`.
    pub async fn search_toll_free_usa_typed<T>(&self, params: &SearchTollFreeUsaParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("searchTollFreeUSA", params).await
    }

    /// Call the `searchVanity` API method.
    pub async fn search_vanity(&self, params: &SearchVanityParams) -> Result<Value> {
        self.call("searchVanity", params).await
    }

    /// Call the `searchVanity` API method and deserialize the response body into `T`.
    pub async fn search_vanity_typed<T>(&self, params: &SearchVanityParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("searchVanity", params).await
    }

    /// Call the `sendCallRecordingEmail` API method.
    pub async fn send_call_recording_email(
        &self,
        params: &SendCallRecordingEmailParams,
    ) -> Result<Value> {
        self.call("sendCallRecordingEmail", params).await
    }

    /// Call the `sendCallRecordingEmail` API method and deserialize the response body into `T`.
    pub async fn send_call_recording_email_typed<T>(
        &self,
        params: &SendCallRecordingEmailParams,
    ) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("sendCallRecordingEmail", params).await
    }

    /// Call the `sendFaxMessage` API method.
    pub async fn send_fax_message(&self, params: &SendFaxMessageParams) -> Result<Value> {
        self.call("sendFaxMessage", params).await
    }

    /// Call the `sendFaxMessage` API method and deserialize the response body into `T`.
    pub async fn send_fax_message_typed<T>(&self, params: &SendFaxMessageParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("sendFaxMessage", params).await
    }

    /// Call the `sendMMS` API method.
    pub async fn send_mms(&self, params: &SendMmsParams) -> Result<Value> {
        self.call("sendMMS", params).await
    }

    /// Call the `sendMMS` API method and deserialize the response body into `T`.
    pub async fn send_mms_typed<T>(&self, params: &SendMmsParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("sendMMS", params).await
    }

    /// Call the `sendSMS` API method.
    pub async fn send_sms(&self, params: &SendSmsParams) -> Result<Value> {
        self.call("sendSMS", params).await
    }

    /// Call the `sendSMS` API method and deserialize the response body into `T`.
    pub async fn send_sms_typed<T>(&self, params: &SendSmsParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("sendSMS", params).await
    }

    /// Call the `sendVoicemailEmail` API method.
    pub async fn send_voicemail_email(&self, params: &SendVoicemailEmailParams) -> Result<Value> {
        self.call("sendVoicemailEmail", params).await
    }

    /// Call the `sendVoicemailEmail` API method and deserialize the response body into `T`.
    pub async fn send_voicemail_email_typed<T>(
        &self,
        params: &SendVoicemailEmailParams,
    ) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("sendVoicemailEmail", params).await
    }

    /// Call the `setCallHunting` API method.
    pub async fn set_call_hunting(&self, params: &SetCallHuntingParams) -> Result<Value> {
        self.call("setCallHunting", params).await
    }

    /// Call the `setCallHunting` API method and deserialize the response body into `T`.
    pub async fn set_call_hunting_typed<T>(&self, params: &SetCallHuntingParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("setCallHunting", params).await
    }

    /// Call the `setCallParking` API method.
    pub async fn set_call_parking(&self, params: &SetCallParkingParams) -> Result<Value> {
        self.call("setCallParking", params).await
    }

    /// Call the `setCallParking` API method and deserialize the response body into `T`.
    pub async fn set_call_parking_typed<T>(&self, params: &SetCallParkingParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("setCallParking", params).await
    }

    /// Call the `setCallback` API method.
    pub async fn set_callback(&self, params: &SetCallbackParams) -> Result<Value> {
        self.call("setCallback", params).await
    }

    /// Call the `setCallback` API method and deserialize the response body into `T`.
    pub async fn set_callback_typed<T>(&self, params: &SetCallbackParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("setCallback", params).await
    }

    /// Call the `setCallerIDFiltering` API method.
    pub async fn set_caller_id_filtering(
        &self,
        params: &SetCallerIdFilteringParams,
    ) -> Result<Value> {
        self.call("setCallerIDFiltering", params).await
    }

    /// Call the `setCallerIDFiltering` API method and deserialize the response body into `T`.
    pub async fn set_caller_id_filtering_typed<T>(
        &self,
        params: &SetCallerIdFilteringParams,
    ) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("setCallerIDFiltering", params).await
    }

    /// Call the `setClient` API method.
    pub async fn set_client(&self, params: &SetClientParams) -> Result<Value> {
        self.call("setClient", params).await
    }

    /// Call the `setClient` API method and deserialize the response body into `T`.
    pub async fn set_client_typed<T>(&self, params: &SetClientParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("setClient", params).await
    }

    /// Call the `setClientThreshold` API method.
    pub async fn set_client_threshold(&self, params: &SetClientThresholdParams) -> Result<Value> {
        self.call("setClientThreshold", params).await
    }

    /// Call the `setClientThreshold` API method and deserialize the response body into `T`.
    pub async fn set_client_threshold_typed<T>(
        &self,
        params: &SetClientThresholdParams,
    ) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("setClientThreshold", params).await
    }

    /// Call the `setConference` API method.
    pub async fn set_conference(&self, params: &SetConferenceParams) -> Result<Value> {
        self.call("setConference", params).await
    }

    /// Call the `setConference` API method and deserialize the response body into `T`.
    pub async fn set_conference_typed<T>(&self, params: &SetConferenceParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("setConference", params).await
    }

    /// Call the `setConferenceMember` API method.
    pub async fn set_conference_member(&self, params: &SetConferenceMemberParams) -> Result<Value> {
        self.call("setConferenceMember", params).await
    }

    /// Call the `setConferenceMember` API method and deserialize the response body into `T`.
    pub async fn set_conference_member_typed<T>(
        &self,
        params: &SetConferenceMemberParams,
    ) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("setConferenceMember", params).await
    }

    /// Call the `setDIDBillingType` API method.
    pub async fn set_did_billing_type(&self, params: &SetDidBillingTypeParams) -> Result<Value> {
        self.call("setDIDBillingType", params).await
    }

    /// Call the `setDIDBillingType` API method and deserialize the response body into `T`.
    pub async fn set_did_billing_type_typed<T>(&self, params: &SetDidBillingTypeParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("setDIDBillingType", params).await
    }

    /// Call the `setDIDInfo` API method.
    pub async fn set_did_info(&self, params: &SetDidInfoParams) -> Result<Value> {
        self.call("setDIDInfo", params).await
    }

    /// Call the `setDIDInfo` API method and deserialize the response body into `T`.
    pub async fn set_did_info_typed<T>(&self, params: &SetDidInfoParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("setDIDInfo", params).await
    }

    /// Call the `setDIDPOP` API method.
    pub async fn set_did_pop(&self, params: &SetDidPopParams) -> Result<Value> {
        self.call("setDIDPOP", params).await
    }

    /// Call the `setDIDPOP` API method and deserialize the response body into `T`.
    pub async fn set_did_pop_typed<T>(&self, params: &SetDidPopParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("setDIDPOP", params).await
    }

    /// Call the `setDIDRouting` API method.
    pub async fn set_did_routing(&self, params: &SetDidRoutingParams) -> Result<Value> {
        self.call("setDIDRouting", params).await
    }

    /// Call the `setDIDRouting` API method and deserialize the response body into `T`.
    pub async fn set_did_routing_typed<T>(&self, params: &SetDidRoutingParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("setDIDRouting", params).await
    }

    /// Call the `setDIDVoicemail` API method.
    pub async fn set_did_voicemail(&self, params: &SetDidVoicemailParams) -> Result<Value> {
        self.call("setDIDVoicemail", params).await
    }

    /// Call the `setDIDVoicemail` API method and deserialize the response body into `T`.
    pub async fn set_did_voicemail_typed<T>(&self, params: &SetDidVoicemailParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("setDIDVoicemail", params).await
    }

    /// Call the `setDISA` API method.
    pub async fn set_disa(&self, params: &SetDisaParams) -> Result<Value> {
        self.call("setDISA", params).await
    }

    /// Call the `setDISA` API method and deserialize the response body into `T`.
    pub async fn set_disa_typed<T>(&self, params: &SetDisaParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("setDISA", params).await
    }

    /// Call the `setEmailToFax` API method.
    pub async fn set_email_to_fax(&self, params: &SetEmailToFaxParams) -> Result<Value> {
        self.call("setEmailToFax", params).await
    }

    /// Call the `setEmailToFax` API method and deserialize the response body into `T`.
    pub async fn set_email_to_fax_typed<T>(&self, params: &SetEmailToFaxParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("setEmailToFax", params).await
    }

    /// Call the `setFaxFolder` API method.
    pub async fn set_fax_folder(&self, params: &SetFaxFolderParams) -> Result<Value> {
        self.call("setFaxFolder", params).await
    }

    /// Call the `setFaxFolder` API method and deserialize the response body into `T`.
    pub async fn set_fax_folder_typed<T>(&self, params: &SetFaxFolderParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("setFaxFolder", params).await
    }

    /// Call the `setFaxNumberEmail` API method.
    pub async fn set_fax_number_email(&self, params: &SetFaxNumberEmailParams) -> Result<Value> {
        self.call("setFaxNumberEmail", params).await
    }

    /// Call the `setFaxNumberEmail` API method and deserialize the response body into `T`.
    pub async fn set_fax_number_email_typed<T>(&self, params: &SetFaxNumberEmailParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("setFaxNumberEmail", params).await
    }

    /// Call the `setFaxNumberInfo` API method.
    pub async fn set_fax_number_info(&self, params: &SetFaxNumberInfoParams) -> Result<Value> {
        self.call("setFaxNumberInfo", params).await
    }

    /// Call the `setFaxNumberInfo` API method and deserialize the response body into `T`.
    pub async fn set_fax_number_info_typed<T>(&self, params: &SetFaxNumberInfoParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("setFaxNumberInfo", params).await
    }

    /// Call the `setFaxNumberURLCallback` API method.
    pub async fn set_fax_number_url_callback(
        &self,
        params: &SetFaxNumberUrlCallbackParams,
    ) -> Result<Value> {
        self.call("setFaxNumberURLCallback", params).await
    }

    /// Call the `setFaxNumberURLCallback` API method and deserialize the response body into `T`.
    pub async fn set_fax_number_url_callback_typed<T>(
        &self,
        params: &SetFaxNumberUrlCallbackParams,
    ) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("setFaxNumberURLCallback", params).await
    }

    /// Call the `setForwarding` API method.
    pub async fn set_forwarding(&self, params: &SetForwardingParams) -> Result<Value> {
        self.call("setForwarding", params).await
    }

    /// Call the `setForwarding` API method and deserialize the response body into `T`.
    pub async fn set_forwarding_typed<T>(&self, params: &SetForwardingParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("setForwarding", params).await
    }

    /// Call the `setIVR` API method.
    pub async fn set_ivr(&self, params: &SetIvrParams) -> Result<Value> {
        self.call("setIVR", params).await
    }

    /// Call the `setIVR` API method and deserialize the response body into `T`.
    pub async fn set_ivr_typed<T>(&self, params: &SetIvrParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("setIVR", params).await
    }

    /// Call the `setLocation` API method.
    pub async fn set_location(&self, params: &SetLocationParams) -> Result<Value> {
        self.call("setLocation", params).await
    }

    /// Call the `setLocation` API method and deserialize the response body into `T`.
    pub async fn set_location_typed<T>(&self, params: &SetLocationParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("setLocation", params).await
    }

    /// Call the `setMusicOnHold` API method.
    pub async fn set_music_on_hold(&self, params: &SetMusicOnHoldParams) -> Result<Value> {
        self.call("setMusicOnHold", params).await
    }

    /// Call the `setMusicOnHold` API method and deserialize the response body into `T`.
    pub async fn set_music_on_hold_typed<T>(&self, params: &SetMusicOnHoldParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("setMusicOnHold", params).await
    }

    /// Call the `setPhonebook` API method.
    pub async fn set_phonebook(&self, params: &SetPhonebookParams) -> Result<Value> {
        self.call("setPhonebook", params).await
    }

    /// Call the `setPhonebook` API method and deserialize the response body into `T`.
    pub async fn set_phonebook_typed<T>(&self, params: &SetPhonebookParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("setPhonebook", params).await
    }

    /// Call the `setPhonebookGroup` API method.
    pub async fn set_phonebook_group(&self, params: &SetPhonebookGroupParams) -> Result<Value> {
        self.call("setPhonebookGroup", params).await
    }

    /// Call the `setPhonebookGroup` API method and deserialize the response body into `T`.
    pub async fn set_phonebook_group_typed<T>(&self, params: &SetPhonebookGroupParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("setPhonebookGroup", params).await
    }

    /// Call the `setQueue` API method.
    pub async fn set_queue(&self, params: &SetQueueParams) -> Result<Value> {
        self.call("setQueue", params).await
    }

    /// Call the `setQueue` API method and deserialize the response body into `T`.
    pub async fn set_queue_typed<T>(&self, params: &SetQueueParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("setQueue", params).await
    }

    /// Call the `setRecording` API method.
    pub async fn set_recording(&self, params: &SetRecordingParams) -> Result<Value> {
        self.call("setRecording", params).await
    }

    /// Call the `setRecording` API method and deserialize the response body into `T`.
    pub async fn set_recording_typed<T>(&self, params: &SetRecordingParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("setRecording", params).await
    }

    /// Call the `setRingGroup` API method.
    pub async fn set_ring_group(&self, params: &SetRingGroupParams) -> Result<Value> {
        self.call("setRingGroup", params).await
    }

    /// Call the `setRingGroup` API method and deserialize the response body into `T`.
    pub async fn set_ring_group_typed<T>(&self, params: &SetRingGroupParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("setRingGroup", params).await
    }

    /// Call the `setSIPURI` API method.
    pub async fn set_sip_uri(&self, params: &SetSipUriParams) -> Result<Value> {
        self.call("setSIPURI", params).await
    }

    /// Call the `setSIPURI` API method and deserialize the response body into `T`.
    pub async fn set_sip_uri_typed<T>(&self, params: &SetSipUriParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("setSIPURI", params).await
    }

    /// Call the `setSMS` API method.
    pub async fn set_sms(&self, params: &SetSmsParams) -> Result<Value> {
        self.call("setSMS", params).await
    }

    /// Call the `setSMS` API method and deserialize the response body into `T`.
    pub async fn set_sms_typed<T>(&self, params: &SetSmsParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("setSMS", params).await
    }

    /// Call the `setStaticMember` API method.
    pub async fn set_static_member(&self, params: &SetStaticMemberParams) -> Result<Value> {
        self.call("setStaticMember", params).await
    }

    /// Call the `setStaticMember` API method and deserialize the response body into `T`.
    pub async fn set_static_member_typed<T>(&self, params: &SetStaticMemberParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("setStaticMember", params).await
    }

    /// Call the `setSubAccount` API method.
    pub async fn set_sub_account(&self, params: &SetSubAccountParams) -> Result<Value> {
        self.call("setSubAccount", params).await
    }

    /// Call the `setSubAccount` API method and deserialize the response body into `T`.
    pub async fn set_sub_account_typed<T>(&self, params: &SetSubAccountParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("setSubAccount", params).await
    }

    /// Call the `setTimeCondition` API method.
    pub async fn set_time_condition(&self, params: &SetTimeConditionParams) -> Result<Value> {
        self.call("setTimeCondition", params).await
    }

    /// Call the `setTimeCondition` API method and deserialize the response body into `T`.
    pub async fn set_time_condition_typed<T>(&self, params: &SetTimeConditionParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("setTimeCondition", params).await
    }

    /// Call the `setVoicemail` API method.
    pub async fn set_voicemail(&self, params: &SetVoicemailParams) -> Result<Value> {
        self.call("setVoicemail", params).await
    }

    /// Call the `setVoicemail` API method and deserialize the response body into `T`.
    pub async fn set_voicemail_typed<T>(&self, params: &SetVoicemailParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("setVoicemail", params).await
    }

    /// Call the `signupClient` API method.
    pub async fn signup_client(&self, params: &SignupClientParams) -> Result<Value> {
        self.call("signupClient", params).await
    }

    /// Call the `signupClient` API method and deserialize the response body into `T`.
    pub async fn signup_client_typed<T>(&self, params: &SignupClientParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("signupClient", params).await
    }

    /// Call the `unconnectDID` API method.
    pub async fn unconnect_did(&self, params: &UnconnectDidParams) -> Result<Value> {
        self.call("unconnectDID", params).await
    }

    /// Call the `unconnectDID` API method and deserialize the response body into `T`.
    pub async fn unconnect_did_typed<T>(&self, params: &UnconnectDidParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("unconnectDID", params).await
    }

    /// Call the `unconnectFAX` API method.
    pub async fn unconnect_fax(&self, params: &UnconnectFaxParams) -> Result<Value> {
        self.call("unconnectFAX", params).await
    }

    /// Call the `unconnectFAX` API method and deserialize the response body into `T`.
    pub async fn unconnect_fax_typed<T>(&self, params: &UnconnectFaxParams) -> Result<T>
    where
        T: DeserializeOwned,
    {
        self.call_typed("unconnectFAX", params).await
    }
}