voip_ms/

generated.rs

// @generated by xtask from tools/server.wsdl + tools/api-responses.json.
// DO NOT EDIT — regenerate with `cargo xtask gen`.

use serde::Serialize;
use serde_json::Value;

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

/// Sub-account call-pickup permissions.
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum CallPickupBehavior {
    /// Can pick up and be picked up.
    PickUpAndBePickedUp,
    /// Can pick up; cannot be picked up.
    PickUpOnly,
    /// Can be picked up; cannot pick up.
    BePickedUpOnly,
    /// Cannot pick up nor be picked up.
    Disabled,
    /// Any wire value this crate doesn't recognize.
    Unknown(String),
}

impl CallPickupBehavior {
    /// The wire string for this variant.
    pub fn as_wire(&self) -> &str {
        match self {
            CallPickupBehavior::PickUpAndBePickedUp => "1",
            CallPickupBehavior::PickUpOnly => "2",
            CallPickupBehavior::BePickedUpOnly => "3",
            CallPickupBehavior::Disabled => "4",
            CallPickupBehavior::Unknown(s) => s.as_str(),
        }
    }

    /// Parse a wire string. Unknown values are preserved.
    pub fn from_wire(s: &str) -> Self {
        match s {
            "1" => CallPickupBehavior::PickUpAndBePickedUp,
            "2" => CallPickupBehavior::PickUpOnly,
            "3" => CallPickupBehavior::BePickedUpOnly,
            "4" => CallPickupBehavior::Disabled,
            other => CallPickupBehavior::Unknown(other.to_string()),
        }
    }
}

impl std::fmt::Display for CallPickupBehavior {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_wire())
    }
}

impl serde::Serialize for CallPickupBehavior {
    fn serialize<S: serde::Serializer>(&self, s: S) -> std::result::Result<S::Ok, S::Error> {
        s.serialize_str(self.as_wire())
    }
}

impl<'de> serde::Deserialize<'de> for CallPickupBehavior {
    fn deserialize<D: serde::Deserializer<'de>>(d: D) -> std::result::Result<Self, D::Error> {
        let s = crate::responses::deserialize_enum_wire_string(d)?;
        Ok(CallPickupBehavior::from_wire(&s))
    }
}

#[allow(dead_code)]
pub(crate) fn deserialize_opt_call_pickup_behavior<'de, D>(
    d: D,
) -> std::result::Result<Option<CallPickupBehavior>, D::Error>
where
    D: serde::Deserializer<'de>,
{
    let opt = crate::responses::deserialize_opt_string_from_string_number_or_bool(d)?;
    Ok(opt.and_then(|s| {
        let t = s.trim();
        if t.is_empty() {
            None
        } else {
            Some(CallPickupBehavior::from_wire(t))
        }
    }))
}

/// Outgoing-call dialing mode for a sub-account.
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum DialingMode {
    /// Use the main account setting.
    MainAccount,
    E164,
    Nanpa,
    /// Any wire value this crate doesn't recognize.
    Unknown(String),
}

impl DialingMode {
    /// The wire string for this variant.
    pub fn as_wire(&self) -> &str {
        match self {
            DialingMode::MainAccount => "0",
            DialingMode::E164 => "1",
            DialingMode::Nanpa => "2",
            DialingMode::Unknown(s) => s.as_str(),
        }
    }

    /// Parse a wire string. Unknown values are preserved.
    pub fn from_wire(s: &str) -> Self {
        match s {
            "0" => DialingMode::MainAccount,
            "1" => DialingMode::E164,
            "2" => DialingMode::Nanpa,
            other => DialingMode::Unknown(other.to_string()),
        }
    }
}

impl std::fmt::Display for DialingMode {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_wire())
    }
}

impl serde::Serialize for DialingMode {
    fn serialize<S: serde::Serializer>(&self, s: S) -> std::result::Result<S::Ok, S::Error> {
        s.serialize_str(self.as_wire())
    }
}

impl<'de> serde::Deserialize<'de> for DialingMode {
    fn deserialize<D: serde::Deserializer<'de>>(d: D) -> std::result::Result<Self, D::Error> {
        let s = crate::responses::deserialize_enum_wire_string(d)?;
        Ok(DialingMode::from_wire(&s))
    }
}

#[allow(dead_code)]
pub(crate) fn deserialize_opt_dialing_mode<'de, D>(
    d: D,
) -> std::result::Result<Option<DialingMode>, D::Error>
where
    D: serde::Deserializer<'de>,
{
    let opt = crate::responses::deserialize_opt_string_from_string_number_or_bool(d)?;
    Ok(opt.and_then(|s| {
        let t = s.trim();
        if t.is_empty() {
            None
        } else {
            Some(DialingMode::from_wire(t))
        }
    }))
}

/// DID billing model.
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum DidBillingType {
    PerMinute,
    Flat,
    /// Any wire value this crate doesn't recognize.
    Unknown(String),
}

impl DidBillingType {
    /// The wire string for this variant.
    pub fn as_wire(&self) -> &str {
        match self {
            DidBillingType::PerMinute => "1",
            DidBillingType::Flat => "2",
            DidBillingType::Unknown(s) => s.as_str(),
        }
    }

    /// Parse a wire string. Unknown values are preserved.
    pub fn from_wire(s: &str) -> Self {
        match s {
            "1" => DidBillingType::PerMinute,
            "2" => DidBillingType::Flat,
            other => DidBillingType::Unknown(other.to_string()),
        }
    }
}

impl std::fmt::Display for DidBillingType {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_wire())
    }
}

impl serde::Serialize for DidBillingType {
    fn serialize<S: serde::Serializer>(&self, s: S) -> std::result::Result<S::Ok, S::Error> {
        s.serialize_str(self.as_wire())
    }
}

impl<'de> serde::Deserialize<'de> for DidBillingType {
    fn deserialize<D: serde::Deserializer<'de>>(d: D) -> std::result::Result<Self, D::Error> {
        let s = crate::responses::deserialize_enum_wire_string(d)?;
        Ok(DidBillingType::from_wire(&s))
    }
}

#[allow(dead_code)]
pub(crate) fn deserialize_opt_did_billing_type<'de, D>(
    d: D,
) -> std::result::Result<Option<DidBillingType>, D::Error>
where
    D: serde::Deserializer<'de>,
{
    let opt = crate::responses::deserialize_opt_string_from_string_number_or_bool(d)?;
    Ok(opt.and_then(|s| {
        let t = s.trim();
        if t.is_empty() {
            None
        } else {
            Some(DidBillingType::from_wire(t))
        }
    }))
}

/// DTMF transport mode for SIP sub-accounts.
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum DtmfMode {
    Auto,
    Rfc2833,
    Inband,
    Info,
    /// Any wire value this crate doesn't recognize.
    Unknown(String),
}

impl DtmfMode {
    /// The wire string for this variant.
    pub fn as_wire(&self) -> &str {
        match self {
            DtmfMode::Auto => "auto",
            DtmfMode::Rfc2833 => "rfc2833",
            DtmfMode::Inband => "inband",
            DtmfMode::Info => "info",
            DtmfMode::Unknown(s) => s.as_str(),
        }
    }

    /// Parse a wire string. Unknown values are preserved.
    pub fn from_wire(s: &str) -> Self {
        match s {
            "auto" => DtmfMode::Auto,
            "rfc2833" => DtmfMode::Rfc2833,
            "inband" => DtmfMode::Inband,
            "info" => DtmfMode::Info,
            other => DtmfMode::Unknown(other.to_string()),
        }
    }
}

impl std::fmt::Display for DtmfMode {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_wire())
    }
}

impl serde::Serialize for DtmfMode {
    fn serialize<S: serde::Serializer>(&self, s: S) -> std::result::Result<S::Ok, S::Error> {
        s.serialize_str(self.as_wire())
    }
}

impl<'de> serde::Deserialize<'de> for DtmfMode {
    fn deserialize<D: serde::Deserializer<'de>>(d: D) -> std::result::Result<Self, D::Error> {
        let s = crate::responses::deserialize_enum_wire_string(d)?;
        Ok(DtmfMode::from_wire(&s))
    }
}

#[allow(dead_code)]
pub(crate) fn deserialize_opt_dtmf_mode<'de, D>(
    d: D,
) -> std::result::Result<Option<DtmfMode>, D::Error>
where
    D: serde::Deserializer<'de>,
{
    let opt = crate::responses::deserialize_opt_string_from_string_number_or_bool(d)?;
    Ok(opt.and_then(|s| {
        let t = s.trim();
        if t.is_empty() {
            None
        } else {
            Some(DtmfMode::from_wire(t))
        }
    }))
}

/// Voicemail email attachment format.
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum EmailAttachmentFormat {
    /// GSM-compressed WAV.
    Wav49,
    Wav,
    /// MP3 (wire value `wavmp3`).
    Mp3,
    /// Do not attach audio.
    No,
    /// Any wire value this crate doesn't recognize.
    Unknown(String),
}

impl EmailAttachmentFormat {
    /// The wire string for this variant.
    pub fn as_wire(&self) -> &str {
        match self {
            EmailAttachmentFormat::Wav49 => "wav49",
            EmailAttachmentFormat::Wav => "wav",
            EmailAttachmentFormat::Mp3 => "wavmp3",
            EmailAttachmentFormat::No => "no",
            EmailAttachmentFormat::Unknown(s) => s.as_str(),
        }
    }

    /// Parse a wire string. Unknown values are preserved.
    pub fn from_wire(s: &str) -> Self {
        match s {
            "wav49" => EmailAttachmentFormat::Wav49,
            "wav" => EmailAttachmentFormat::Wav,
            "wavmp3" => EmailAttachmentFormat::Mp3,
            "no" => EmailAttachmentFormat::No,
            other => EmailAttachmentFormat::Unknown(other.to_string()),
        }
    }
}

impl std::fmt::Display for EmailAttachmentFormat {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_wire())
    }
}

impl serde::Serialize for EmailAttachmentFormat {
    fn serialize<S: serde::Serializer>(&self, s: S) -> std::result::Result<S::Ok, S::Error> {
        s.serialize_str(self.as_wire())
    }
}

impl<'de> serde::Deserialize<'de> for EmailAttachmentFormat {
    fn deserialize<D: serde::Deserializer<'de>>(d: D) -> std::result::Result<Self, D::Error> {
        let s = crate::responses::deserialize_enum_wire_string(d)?;
        Ok(EmailAttachmentFormat::from_wire(&s))
    }
}

#[allow(dead_code)]
pub(crate) fn deserialize_opt_email_attachment_format<'de, D>(
    d: D,
) -> std::result::Result<Option<EmailAttachmentFormat>, D::Error>
where
    D: serde::Deserializer<'de>,
{
    let opt = crate::responses::deserialize_opt_string_from_string_number_or_bool(d)?;
    Ok(opt.and_then(|s| {
        let t = s.trim();
        if t.is_empty() {
            None
        } else {
            Some(EmailAttachmentFormat::from_wire(t))
        }
    }))
}

/// When to include estimated hold time in queue position announcements.
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum EstimatedHoldTimeAnnounce {
    Yes,
    No,
    /// Announce only the first time.
    Once,
    /// Any wire value this crate doesn't recognize.
    Unknown(String),
}

impl EstimatedHoldTimeAnnounce {
    /// The wire string for this variant.
    pub fn as_wire(&self) -> &str {
        match self {
            EstimatedHoldTimeAnnounce::Yes => "yes",
            EstimatedHoldTimeAnnounce::No => "no",
            EstimatedHoldTimeAnnounce::Once => "once",
            EstimatedHoldTimeAnnounce::Unknown(s) => s.as_str(),
        }
    }

    /// Parse a wire string. Unknown values are preserved.
    pub fn from_wire(s: &str) -> Self {
        match s {
            "yes" => EstimatedHoldTimeAnnounce::Yes,
            "no" => EstimatedHoldTimeAnnounce::No,
            "once" => EstimatedHoldTimeAnnounce::Once,
            other => EstimatedHoldTimeAnnounce::Unknown(other.to_string()),
        }
    }
}

impl std::fmt::Display for EstimatedHoldTimeAnnounce {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_wire())
    }
}

impl serde::Serialize for EstimatedHoldTimeAnnounce {
    fn serialize<S: serde::Serializer>(&self, s: S) -> std::result::Result<S::Ok, S::Error> {
        s.serialize_str(self.as_wire())
    }
}

impl<'de> serde::Deserialize<'de> for EstimatedHoldTimeAnnounce {
    fn deserialize<D: serde::Deserializer<'de>>(d: D) -> std::result::Result<Self, D::Error> {
        let s = crate::responses::deserialize_enum_wire_string(d)?;
        Ok(EstimatedHoldTimeAnnounce::from_wire(&s))
    }
}

#[allow(dead_code)]
pub(crate) fn deserialize_opt_estimated_hold_time_announce<'de, D>(
    d: D,
) -> std::result::Result<Option<EstimatedHoldTimeAnnounce>, D::Error>
where
    D: serde::Deserializer<'de>,
{
    let opt = crate::responses::deserialize_opt_string_from_string_number_or_bool(d)?;
    Ok(opt.and_then(|s| {
        let t = s.trim();
        if t.is_empty() {
            None
        } else {
            Some(EstimatedHoldTimeAnnounce::from_wire(t))
        }
    }))
}

/// Type of service location for an LNP port.
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum LocationType {
    Residential,
    Business,
    /// Any wire value this crate doesn't recognize.
    Unknown(String),
}

impl LocationType {
    /// The wire string for this variant.
    pub fn as_wire(&self) -> &str {
        match self {
            LocationType::Residential => "0",
            LocationType::Business => "1",
            LocationType::Unknown(s) => s.as_str(),
        }
    }

    /// Parse a wire string. Unknown values are preserved.
    pub fn from_wire(s: &str) -> Self {
        match s {
            "0" => LocationType::Residential,
            "1" => LocationType::Business,
            other => LocationType::Unknown(other.to_string()),
        }
    }
}

impl std::fmt::Display for LocationType {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_wire())
    }
}

impl serde::Serialize for LocationType {
    fn serialize<S: serde::Serializer>(&self, s: S) -> std::result::Result<S::Ok, S::Error> {
        s.serialize_str(self.as_wire())
    }
}

impl<'de> serde::Deserialize<'de> for LocationType {
    fn deserialize<D: serde::Deserializer<'de>>(d: D) -> std::result::Result<Self, D::Error> {
        let s = crate::responses::deserialize_enum_wire_string(d)?;
        Ok(LocationType::from_wire(&s))
    }
}

#[allow(dead_code)]
pub(crate) fn deserialize_opt_location_type<'de, D>(
    d: D,
) -> std::result::Result<Option<LocationType>, D::Error>
where
    D: serde::Deserializer<'de>,
{
    let opt = crate::responses::deserialize_opt_string_from_string_number_or_bool(d)?;
    Ok(opt.and_then(|s| {
        let t = s.trim();
        if t.is_empty() {
            None
        } else {
            Some(LocationType::from_wire(t))
        }
    }))
}

/// Direction of an SMS / MMS message: a filter on requests, the direction on results.
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum MessageType {
    Received,
    Sent,
    /// Any wire value this crate doesn't recognize.
    Unknown(String),
}

impl MessageType {
    /// The wire string for this variant.
    pub fn as_wire(&self) -> &str {
        match self {
            MessageType::Received => "1",
            MessageType::Sent => "0",
            MessageType::Unknown(s) => s.as_str(),
        }
    }

    /// Parse a wire string. Unknown values are preserved.
    pub fn from_wire(s: &str) -> Self {
        match s {
            "1" => MessageType::Received,
            "0" => MessageType::Sent,
            other => MessageType::Unknown(other.to_string()),
        }
    }
}

impl std::fmt::Display for MessageType {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_wire())
    }
}

impl serde::Serialize for MessageType {
    fn serialize<S: serde::Serializer>(&self, s: S) -> std::result::Result<S::Ok, S::Error> {
        s.serialize_str(self.as_wire())
    }
}

impl<'de> serde::Deserialize<'de> for MessageType {
    fn deserialize<D: serde::Deserializer<'de>>(d: D) -> std::result::Result<Self, D::Error> {
        let s = crate::responses::deserialize_enum_wire_string(d)?;
        Ok(MessageType::from_wire(&s))
    }
}

#[allow(dead_code)]
pub(crate) fn deserialize_opt_message_type<'de, D>(
    d: D,
) -> std::result::Result<Option<MessageType>, D::Error>
where
    D: serde::Deserializer<'de>,
{
    let opt = crate::responses::deserialize_opt_string_from_string_number_or_bool(d)?;
    Ok(opt.and_then(|s| {
        let t = s.trim();
        if t.is_empty() {
            None
        } else {
            Some(MessageType::from_wire(t))
        }
    }))
}

/// Asterisk NAT handling mode.
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum Nat {
    Yes,
    No,
    Route,
    Never,
    /// Any wire value this crate doesn't recognize.
    Unknown(String),
}

impl Nat {
    /// The wire string for this variant.
    pub fn as_wire(&self) -> &str {
        match self {
            Nat::Yes => "yes",
            Nat::No => "no",
            Nat::Route => "route",
            Nat::Never => "never",
            Nat::Unknown(s) => s.as_str(),
        }
    }

    /// Parse a wire string. Unknown values are preserved.
    pub fn from_wire(s: &str) -> Self {
        match s {
            "yes" => Nat::Yes,
            "no" => Nat::No,
            "route" => Nat::Route,
            "never" => Nat::Never,
            other => Nat::Unknown(other.to_string()),
        }
    }
}

impl std::fmt::Display for Nat {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_wire())
    }
}

impl serde::Serialize for Nat {
    fn serialize<S: serde::Serializer>(&self, s: S) -> std::result::Result<S::Ok, S::Error> {
        s.serialize_str(self.as_wire())
    }
}

impl<'de> serde::Deserialize<'de> for Nat {
    fn deserialize<D: serde::Deserializer<'de>>(d: D) -> std::result::Result<Self, D::Error> {
        let s = crate::responses::deserialize_enum_wire_string(d)?;
        Ok(Nat::from_wire(&s))
    }
}

#[allow(dead_code)]
pub(crate) fn deserialize_opt_nat<'de, D>(d: D) -> std::result::Result<Option<Nat>, D::Error>
where
    D: serde::Deserializer<'de>,
{
    let opt = crate::responses::deserialize_opt_string_from_string_number_or_bool(d)?;
    Ok(opt.and_then(|s| {
        let t = s.trim();
        if t.is_empty() {
            None
        } else {
            Some(Nat::from_wire(t))
        }
    }))
}

/// Voicemail playback instruction mode.
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum PlayInstructions {
    /// Skip instructions on unread messages.
    SkipUnread,
    /// Read full instructions for unread messages.
    Unread,
    /// Any wire value this crate doesn't recognize.
    Unknown(String),
}

impl PlayInstructions {
    /// The wire string for this variant.
    pub fn as_wire(&self) -> &str {
        match self {
            PlayInstructions::SkipUnread => "su",
            PlayInstructions::Unread => "u",
            PlayInstructions::Unknown(s) => s.as_str(),
        }
    }

    /// Parse a wire string. Unknown values are preserved.
    pub fn from_wire(s: &str) -> Self {
        match s {
            "su" => PlayInstructions::SkipUnread,
            "u" => PlayInstructions::Unread,
            other => PlayInstructions::Unknown(other.to_string()),
        }
    }
}

impl std::fmt::Display for PlayInstructions {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_wire())
    }
}

impl serde::Serialize for PlayInstructions {
    fn serialize<S: serde::Serializer>(&self, s: S) -> std::result::Result<S::Ok, S::Error> {
        s.serialize_str(self.as_wire())
    }
}

impl<'de> serde::Deserialize<'de> for PlayInstructions {
    fn deserialize<D: serde::Deserializer<'de>>(d: D) -> std::result::Result<Self, D::Error> {
        let s = crate::responses::deserialize_enum_wire_string(d)?;
        Ok(PlayInstructions::from_wire(&s))
    }
}

#[allow(dead_code)]
pub(crate) fn deserialize_opt_play_instructions<'de, D>(
    d: D,
) -> std::result::Result<Option<PlayInstructions>, D::Error>
where
    D: serde::Deserializer<'de>,
{
    let opt = crate::responses::deserialize_opt_string_from_string_number_or_bool(d)?;
    Ok(opt.and_then(|s| {
        let t = s.trim();
        if t.is_empty() {
            None
        } else {
            Some(PlayInstructions::from_wire(t))
        }
    }))
}

/// Whether callers may join, or are kept in, a queue with no available members. Used by both `join_when_empty` and `leave_when_empty`.
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum QueueEmptyBehavior {
    /// Callers may join / remain with no members.
    Yes,
    /// Callers may not join / are sent to failover.
    No,
    /// Like `No`, but also applies when members are present yet all unavailable.
    Strict,
    /// Any wire value this crate doesn't recognize.
    Unknown(String),
}

impl QueueEmptyBehavior {
    /// The wire string for this variant.
    pub fn as_wire(&self) -> &str {
        match self {
            QueueEmptyBehavior::Yes => "yes",
            QueueEmptyBehavior::No => "no",
            QueueEmptyBehavior::Strict => "strict",
            QueueEmptyBehavior::Unknown(s) => s.as_str(),
        }
    }

    /// Parse a wire string. Unknown values are preserved.
    pub fn from_wire(s: &str) -> Self {
        match s {
            "yes" => QueueEmptyBehavior::Yes,
            "no" => QueueEmptyBehavior::No,
            "strict" => QueueEmptyBehavior::Strict,
            other => QueueEmptyBehavior::Unknown(other.to_string()),
        }
    }
}

impl std::fmt::Display for QueueEmptyBehavior {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_wire())
    }
}

impl serde::Serialize for QueueEmptyBehavior {
    fn serialize<S: serde::Serializer>(&self, s: S) -> std::result::Result<S::Ok, S::Error> {
        s.serialize_str(self.as_wire())
    }
}

impl<'de> serde::Deserialize<'de> for QueueEmptyBehavior {
    fn deserialize<D: serde::Deserializer<'de>>(d: D) -> std::result::Result<Self, D::Error> {
        let s = crate::responses::deserialize_enum_wire_string(d)?;
        Ok(QueueEmptyBehavior::from_wire(&s))
    }
}

#[allow(dead_code)]
pub(crate) fn deserialize_opt_queue_empty_behavior<'de, D>(
    d: D,
) -> std::result::Result<Option<QueueEmptyBehavior>, D::Error>
where
    D: serde::Deserializer<'de>,
{
    let opt = crate::responses::deserialize_opt_string_from_string_number_or_bool(d)?;
    Ok(opt.and_then(|s| {
        let t = s.trim();
        if t.is_empty() {
            None
        } else {
            Some(QueueEmptyBehavior::from_wire(t))
        }
    }))
}

/// Sort order for selected recordings.
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum RecordingSort {
    Alpha,
    Random,
    /// Any wire value this crate doesn't recognize.
    Unknown(String),
}

impl RecordingSort {
    /// The wire string for this variant.
    pub fn as_wire(&self) -> &str {
        match self {
            RecordingSort::Alpha => "alpha",
            RecordingSort::Random => "random",
            RecordingSort::Unknown(s) => s.as_str(),
        }
    }

    /// Parse a wire string. Unknown values are preserved.
    pub fn from_wire(s: &str) -> Self {
        match s {
            "alpha" => RecordingSort::Alpha,
            "random" => RecordingSort::Random,
            other => RecordingSort::Unknown(other.to_string()),
        }
    }
}

impl std::fmt::Display for RecordingSort {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_wire())
    }
}

impl serde::Serialize for RecordingSort {
    fn serialize<S: serde::Serializer>(&self, s: S) -> std::result::Result<S::Ok, S::Error> {
        s.serialize_str(self.as_wire())
    }
}

impl<'de> serde::Deserialize<'de> for RecordingSort {
    fn deserialize<D: serde::Deserializer<'de>>(d: D) -> std::result::Result<Self, D::Error> {
        let s = crate::responses::deserialize_enum_wire_string(d)?;
        Ok(RecordingSort::from_wire(&s))
    }
}

#[allow(dead_code)]
pub(crate) fn deserialize_opt_recording_sort<'de, D>(
    d: D,
) -> std::result::Result<Option<RecordingSort>, D::Error>
where
    D: serde::Deserializer<'de>,
{
    let opt = crate::responses::deserialize_opt_string_from_string_number_or_bool(d)?;
    Ok(opt.and_then(|s| {
        let t = s.trim();
        if t.is_empty() {
            None
        } else {
            Some(RecordingSort::from_wire(t))
        }
    }))
}

/// Order in which ring-group members are attempted.
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum RingGroupOrder {
    /// Try members in declared order.
    Follow,
    Random,
    /// Any wire value this crate doesn't recognize.
    Unknown(String),
}

impl RingGroupOrder {
    /// The wire string for this variant.
    pub fn as_wire(&self) -> &str {
        match self {
            RingGroupOrder::Follow => "follow",
            RingGroupOrder::Random => "random",
            RingGroupOrder::Unknown(s) => s.as_str(),
        }
    }

    /// Parse a wire string. Unknown values are preserved.
    pub fn from_wire(s: &str) -> Self {
        match s {
            "follow" => RingGroupOrder::Follow,
            "random" => RingGroupOrder::Random,
            other => RingGroupOrder::Unknown(other.to_string()),
        }
    }
}

impl std::fmt::Display for RingGroupOrder {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_wire())
    }
}

impl serde::Serialize for RingGroupOrder {
    fn serialize<S: serde::Serializer>(&self, s: S) -> std::result::Result<S::Ok, S::Error> {
        s.serialize_str(self.as_wire())
    }
}

impl<'de> serde::Deserialize<'de> for RingGroupOrder {
    fn deserialize<D: serde::Deserializer<'de>>(d: D) -> std::result::Result<Self, D::Error> {
        let s = crate::responses::deserialize_enum_wire_string(d)?;
        Ok(RingGroupOrder::from_wire(&s))
    }
}

#[allow(dead_code)]
pub(crate) fn deserialize_opt_ring_group_order<'de, D>(
    d: D,
) -> std::result::Result<Option<RingGroupOrder>, D::Error>
where
    D: serde::Deserializer<'de>,
{
    let opt = crate::responses::deserialize_opt_string_from_string_number_or_bool(d)?;
    Ok(opt.and_then(|s| {
        let t = s.trim();
        if t.is_empty() {
            None
        } else {
            Some(RingGroupOrder::from_wire(t))
        }
    }))
}

/// Queue ring strategy. Mirrors Asterisk's queue strategy options.
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum RingStrategy {
    RingAll,
    LeastRecent,
    FewestCalls,
    Random,
    RrMemory,
    /// Any wire value this crate doesn't recognize.
    Unknown(String),
}

impl RingStrategy {
    /// The wire string for this variant.
    pub fn as_wire(&self) -> &str {
        match self {
            RingStrategy::RingAll => "ringall",
            RingStrategy::LeastRecent => "leastrecent",
            RingStrategy::FewestCalls => "fewestcalls",
            RingStrategy::Random => "random",
            RingStrategy::RrMemory => "rrmemory",
            RingStrategy::Unknown(s) => s.as_str(),
        }
    }

    /// Parse a wire string. Unknown values are preserved.
    pub fn from_wire(s: &str) -> Self {
        match s {
            "ringall" => RingStrategy::RingAll,
            "leastrecent" => RingStrategy::LeastRecent,
            "fewestcalls" => RingStrategy::FewestCalls,
            "random" => RingStrategy::Random,
            "rrmemory" => RingStrategy::RrMemory,
            other => RingStrategy::Unknown(other.to_string()),
        }
    }
}

impl std::fmt::Display for RingStrategy {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_wire())
    }
}

impl serde::Serialize for RingStrategy {
    fn serialize<S: serde::Serializer>(&self, s: S) -> std::result::Result<S::Ok, S::Error> {
        s.serialize_str(self.as_wire())
    }
}

impl<'de> serde::Deserialize<'de> for RingStrategy {
    fn deserialize<D: serde::Deserializer<'de>>(d: D) -> std::result::Result<Self, D::Error> {
        let s = crate::responses::deserialize_enum_wire_string(d)?;
        Ok(RingStrategy::from_wire(&s))
    }
}

#[allow(dead_code)]
pub(crate) fn deserialize_opt_ring_strategy<'de, D>(
    d: D,
) -> std::result::Result<Option<RingStrategy>, D::Error>
where
    D: serde::Deserializer<'de>,
{
    let opt = crate::responses::deserialize_opt_string_from_string_number_or_bool(d)?;
    Ok(opt.and_then(|s| {
        let t = s.trim();
        if t.is_empty() {
            None
        } else {
            Some(RingStrategy::from_wire(t))
        }
    }))
}

/// How a DID / toll-free search string is matched.
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum SearchType {
    Starts,
    Contains,
    Ends,
    /// Any wire value this crate doesn't recognize.
    Unknown(String),
}

impl SearchType {
    /// The wire string for this variant.
    pub fn as_wire(&self) -> &str {
        match self {
            SearchType::Starts => "starts",
            SearchType::Contains => "contains",
            SearchType::Ends => "ends",
            SearchType::Unknown(s) => s.as_str(),
        }
    }

    /// Parse a wire string. Unknown values are preserved.
    pub fn from_wire(s: &str) -> Self {
        match s {
            "starts" => SearchType::Starts,
            "contains" => SearchType::Contains,
            "ends" => SearchType::Ends,
            other => SearchType::Unknown(other.to_string()),
        }
    }
}

impl std::fmt::Display for SearchType {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_wire())
    }
}

impl serde::Serialize for SearchType {
    fn serialize<S: serde::Serializer>(&self, s: S) -> std::result::Result<S::Ok, S::Error> {
        s.serialize_str(self.as_wire())
    }
}

impl<'de> serde::Deserialize<'de> for SearchType {
    fn deserialize<D: serde::Deserializer<'de>>(d: D) -> std::result::Result<Self, D::Error> {
        let s = crate::responses::deserialize_enum_wire_string(d)?;
        Ok(SearchType::from_wire(&s))
    }
}

#[allow(dead_code)]
pub(crate) fn deserialize_opt_search_type<'de, D>(
    d: D,
) -> std::result::Result<Option<SearchType>, D::Error>
where
    D: serde::Deserializer<'de>,
{
    let opt = crate::responses::deserialize_opt_string_from_string_number_or_bool(d)?;
    Ok(opt.and_then(|s| {
        let t = s.trim();
        if t.is_empty() {
            None
        } else {
            Some(SearchType::from_wire(t))
        }
    }))
}

/// Carrier for outgoing calls to toll-free numbers.
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum TollFreeCarrier {
    /// Use the main account setting.
    MainAccount,
    /// Default server setting.
    Default,
    Us,
    Canadian,
    /// Any wire value this crate doesn't recognize.
    Unknown(String),
}

impl TollFreeCarrier {
    /// The wire string for this variant.
    pub fn as_wire(&self) -> &str {
        match self {
            TollFreeCarrier::MainAccount => "-1",
            TollFreeCarrier::Default => "0",
            TollFreeCarrier::Us => "1",
            TollFreeCarrier::Canadian => "2",
            TollFreeCarrier::Unknown(s) => s.as_str(),
        }
    }

    /// Parse a wire string. Unknown values are preserved.
    pub fn from_wire(s: &str) -> Self {
        match s {
            "-1" => TollFreeCarrier::MainAccount,
            "0" => TollFreeCarrier::Default,
            "1" => TollFreeCarrier::Us,
            "2" => TollFreeCarrier::Canadian,
            other => TollFreeCarrier::Unknown(other.to_string()),
        }
    }
}

impl std::fmt::Display for TollFreeCarrier {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_wire())
    }
}

impl serde::Serialize for TollFreeCarrier {
    fn serialize<S: serde::Serializer>(&self, s: S) -> std::result::Result<S::Ok, S::Error> {
        s.serialize_str(self.as_wire())
    }
}

impl<'de> serde::Deserialize<'de> for TollFreeCarrier {
    fn deserialize<D: serde::Deserializer<'de>>(d: D) -> std::result::Result<Self, D::Error> {
        let s = crate::responses::deserialize_enum_wire_string(d)?;
        Ok(TollFreeCarrier::from_wire(&s))
    }
}

#[allow(dead_code)]
pub(crate) fn deserialize_opt_toll_free_carrier<'de, D>(
    d: D,
) -> std::result::Result<Option<TollFreeCarrier>, D::Error>
where
    D: serde::Deserializer<'de>,
{
    let opt = crate::responses::deserialize_opt_string_from_string_number_or_bool(d)?;
    Ok(opt.and_then(|s| {
        let t = s.trim();
        if t.is_empty() {
            None
        } else {
            Some(TollFreeCarrier::from_wire(t))
        }
    }))
}

/// Voicemail transcription output format.
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum TranscriptionFormat {
    Text,
    Html,
    /// Any wire value this crate doesn't recognize.
    Unknown(String),
}

impl TranscriptionFormat {
    /// The wire string for this variant.
    pub fn as_wire(&self) -> &str {
        match self {
            TranscriptionFormat::Text => "text",
            TranscriptionFormat::Html => "html",
            TranscriptionFormat::Unknown(s) => s.as_str(),
        }
    }

    /// Parse a wire string. Unknown values are preserved.
    pub fn from_wire(s: &str) -> Self {
        match s {
            "text" => TranscriptionFormat::Text,
            "html" => TranscriptionFormat::Html,
            other => TranscriptionFormat::Unknown(other.to_string()),
        }
    }
}

impl std::fmt::Display for TranscriptionFormat {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_wire())
    }
}

impl serde::Serialize for TranscriptionFormat {
    fn serialize<S: serde::Serializer>(&self, s: S) -> std::result::Result<S::Ok, S::Error> {
        s.serialize_str(self.as_wire())
    }
}

impl<'de> serde::Deserialize<'de> for TranscriptionFormat {
    fn deserialize<D: serde::Deserializer<'de>>(d: D) -> std::result::Result<Self, D::Error> {
        let s = crate::responses::deserialize_enum_wire_string(d)?;
        Ok(TranscriptionFormat::from_wire(&s))
    }
}

#[allow(dead_code)]
pub(crate) fn deserialize_opt_transcription_format<'de, D>(
    d: D,
) -> std::result::Result<Option<TranscriptionFormat>, D::Error>
where
    D: serde::Deserializer<'de>,
{
    let opt = crate::responses::deserialize_opt_string_from_string_number_or_bool(d)?;
    Ok(opt.and_then(|s| {
        let t = s.trim();
        if t.is_empty() {
            None
        } else {
            Some(TranscriptionFormat::from_wire(t))
        }
    }))
}

/// Toll-free prefix to search for a vanity number.
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum VanityType {
    /// Any toll-free prefix.
    Any,
    N800,
    N833,
    N844,
    N855,
    N866,
    N877,
    N888,
    /// Any wire value this crate doesn't recognize.
    Unknown(String),
}

impl VanityType {
    /// The wire string for this variant.
    pub fn as_wire(&self) -> &str {
        match self {
            VanityType::Any => "8**",
            VanityType::N800 => "800",
            VanityType::N833 => "833",
            VanityType::N844 => "844",
            VanityType::N855 => "855",
            VanityType::N866 => "866",
            VanityType::N877 => "877",
            VanityType::N888 => "888",
            VanityType::Unknown(s) => s.as_str(),
        }
    }

    /// Parse a wire string. Unknown values are preserved.
    pub fn from_wire(s: &str) -> Self {
        match s {
            "8**" => VanityType::Any,
            "800" => VanityType::N800,
            "833" => VanityType::N833,
            "844" => VanityType::N844,
            "855" => VanityType::N855,
            "866" => VanityType::N866,
            "877" => VanityType::N877,
            "888" => VanityType::N888,
            other => VanityType::Unknown(other.to_string()),
        }
    }
}

impl std::fmt::Display for VanityType {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_wire())
    }
}

impl serde::Serialize for VanityType {
    fn serialize<S: serde::Serializer>(&self, s: S) -> std::result::Result<S::Ok, S::Error> {
        s.serialize_str(self.as_wire())
    }
}

impl<'de> serde::Deserialize<'de> for VanityType {
    fn deserialize<D: serde::Deserializer<'de>>(d: D) -> std::result::Result<Self, D::Error> {
        let s = crate::responses::deserialize_enum_wire_string(d)?;
        Ok(VanityType::from_wire(&s))
    }
}

#[allow(dead_code)]
pub(crate) fn deserialize_opt_vanity_type<'de, D>(
    d: D,
) -> std::result::Result<Option<VanityType>, D::Error>
where
    D: serde::Deserializer<'de>,
{
    let opt = crate::responses::deserialize_opt_string_from_string_number_or_bool(d)?;
    Ok(opt.and_then(|s| {
        let t = s.trim();
        if t.is_empty() {
            None
        } else {
            Some(VanityType::from_wire(t))
        }
    }))
}

/// Voicemail message folder.
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum VoicemailFolder {
    Inbox,
    Old,
    Urgent,
    Family,
    Friends,
    Work,
    /// Any wire value this crate doesn't recognize.
    Unknown(String),
}

impl VoicemailFolder {
    /// The wire string for this variant.
    pub fn as_wire(&self) -> &str {
        match self {
            VoicemailFolder::Inbox => "INBOX",
            VoicemailFolder::Old => "Old",
            VoicemailFolder::Urgent => "Urgent",
            VoicemailFolder::Family => "Family",
            VoicemailFolder::Friends => "Friends",
            VoicemailFolder::Work => "Work",
            VoicemailFolder::Unknown(s) => s.as_str(),
        }
    }

    /// Parse a wire string. Unknown values are preserved.
    pub fn from_wire(s: &str) -> Self {
        match s {
            "INBOX" => VoicemailFolder::Inbox,
            "Old" => VoicemailFolder::Old,
            "Urgent" => VoicemailFolder::Urgent,
            "Family" => VoicemailFolder::Family,
            "Friends" => VoicemailFolder::Friends,
            "Work" => VoicemailFolder::Work,
            other => VoicemailFolder::Unknown(other.to_string()),
        }
    }
}

impl std::fmt::Display for VoicemailFolder {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_wire())
    }
}

impl serde::Serialize for VoicemailFolder {
    fn serialize<S: serde::Serializer>(&self, s: S) -> std::result::Result<S::Ok, S::Error> {
        s.serialize_str(self.as_wire())
    }
}

impl<'de> serde::Deserialize<'de> for VoicemailFolder {
    fn deserialize<D: serde::Deserializer<'de>>(d: D) -> std::result::Result<Self, D::Error> {
        let s = crate::responses::deserialize_enum_wire_string(d)?;
        Ok(VoicemailFolder::from_wire(&s))
    }
}

#[allow(dead_code)]
pub(crate) fn deserialize_opt_voicemail_folder<'de, D>(
    d: D,
) -> std::result::Result<Option<VoicemailFolder>, D::Error>
where
    D: serde::Deserializer<'de>,
{
    let opt = crate::responses::deserialize_opt_string_from_string_number_or_bool(d)?;
    Ok(opt.and_then(|s| {
        let t = s.trim();
        if t.is_empty() {
            None
        } else {
            Some(VoicemailFolder::from_wire(t))
        }
    }))
}

/// A non-success `status` returned by the VoIP.ms API.
///
/// Every documented error code from the official API docs' global
/// error-code table is a variant; [`ApiStatus::description`] returns its
/// documented meaning. The set of codes is documentation, not a stable
/// contract — a code VoIP.ms returns but hasn't documented is preserved
/// verbatim in [`ApiStatus::Unknown`] rather than lost.
///
/// ```
/// # use voip_ms::ApiStatus;
/// let status = ApiStatus::from_wire("invalid_credentials");
/// assert_eq!(status, ApiStatus::InvalidCredentials);
/// assert_eq!(status.as_str(), "invalid_credentials");
/// assert_eq!(status.description(), Some("Username or Password is incorrect"));
/// assert!(status.is_documented());
///
/// let unknown = ApiStatus::from_wire("some_new_code");
/// assert_eq!(unknown, ApiStatus::Unknown("some_new_code".to_string()));
/// assert_eq!(unknown.description(), None);
/// assert!(!unknown.is_documented());
/// ```
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub enum ApiStatus {
    /// `account_with_dids` — The Account has DIDs assigned to it.
    AccountWithDIDs,
    /// `api_limit_exceeded` — API requests limit per minute has been reached
    APILimitExceeded,
    /// `api_not_enabled` — API has not been enabled or has been disabled
    APINotEnabled,
    /// `cancel_failed` — The cancellation wasn't completed.
    CancelFailed,
    /// `can_have_only_one_profile_without_pin` — The conference can just have one profile member without pin
    CANHaveOnlyOneProfileWithoutPIN,
    /// `conference_member_relation_not_found` — There is no relation between the profile member and the conference.
    ConferenceMemberRelationNotFound,
    /// `did_in_use` — DID Number is already in use
    DIDInUse,
    /// `did_limit_reached` — You have reached the maximum number of DID numbers allowed for your account type. Please contact our team if you have a specific use case or if you would like to upgrade to a Business account.
    DIDLimitReached,
    /// `duplicated_name` — There is already another entry with this name
    DuplicatedName,
    /// `duplicated_pin` — The given pin has been duplicated
    DuplicatedPIN,
    /// `e911_disabled` — DID e911 service it's not enabled.
    E911Disabled,
    /// `e911_pending` — DID e911 service has been requested and is in validation process.
    E911Pending,
    /// `error_deleting_msg` — Error when deleting message
    ErrorDeletingMsg,
    /// `error_moving_msg` — Error when move the voicemail message to folder
    ErrorMovingMsg,
    /// `exceeds_file_size` — The file exceeds the limite size allowed.
    ExceedsFileSize,
    /// `existing_did` — You can't set a callback to an existing VoIP.ms DID number
    ExistingDID,
    /// `forwards_exceeded` — Your account is limited to 4 forward entries
    ForwardsExceeded,
    /// `invalid_account` — This is not a valid account
    InvalidAccount,
    /// `invalid_address` — Address is missing or the format is invalid.
    InvalidAddress,
    /// `invalid_admin` — This is not a valid admin
    InvalidAdmin,
    /// `invalid_agent_ring_timeout` — This is not a valid Agent ring time out value
    InvalidAgentRingTimeout,
    /// `invalid_allowedcodecs` — One of the codecs provided is invalid Format and Values: ulaw;g729;gsm;all
    InvalidAllowedcodecs,
    /// `invalid_announce_join_leave` — This is not a valid "Announce join leave"
    InvalidAnnounceJoinLeave,
    /// `invalid_announce_only_user` — This is not a valid "Announce only user"
    InvalidAnnounceOnlyUser,
    /// `invalid_announce_position_frequency` — This is not a valid Announce position frequency
    InvalidAnnouncePositionFrequency,
    /// `invalid_announce_round_seconds` — This is not a valid "Announce round seconds"
    InvalidAnnounceRoundSeconds,
    /// `invalid_announce_user_count` — This is not a valid "Announce user count"
    InvalidAnnounceUserCount,
    /// `invalid_area_code` — this is not a valid Area Code.
    InvalidAreaCode,
    /// `invalid_attachid` — The given ID is invalid or doesn't exist.
    InvalidAttachid,
    /// `invalid_attachmessage` — this is not a valid AttachMessage Should be: yes/no
    InvalidAttachmessage,
    /// `invalid_attach_file` — Valid formats: PDF, MS Word, BMP, JPG
    InvalidAttachFile,
    /// `invalid_authtype` — This is not a valid Auth Type
    InvalidAuthtype,
    /// `invalid_authtype_h323` — You must select IP Auth to use H.323
    InvalidAuthtypeH323,
    /// `invalid_authtype_iax2` — You must use User/Password Authentication for IAX2
    InvalidAuthtypeIax2,
    /// `invalid_balancemanagement` — This is not a valid BalanceManagement
    InvalidBalancemanagement,
    /// `invalid_base_recording` — This is not a valid recording path
    InvalidBaseRecording,
    /// `invalid_billingtype` — This is not a valid Billing Type Allowed values: 1 = PerMinute, 2 = Flat
    InvalidBillingtype,
    /// `invalid_callback` — This is not a valid Callback
    InvalidCallback,
    /// `invalid_callback_enable` — This is not a valid Callback enable value
    InvalidCallbackEnable,
    /// `invalid_callback_retry` — This is not a valid Callback retry
    InvalidCallbackRetry,
    /// `invalid_callerid` — This is not a valid CallerID
    InvalidCallerid,
    /// `invalid_calleridprefix` — This is not a valid CID Prefix, lenght should be less than 20 chars
    InvalidCalleridprefix,
    /// `invalid_callerid_override` — This is not a valid CallerID Override
    InvalidCalleridOverride,
    /// `invalid_callhunting` — This is not a valid Call Hunting
    InvalidCallhunting,
    /// `invalid_callparking` — This is not a valid Call Parking
    InvalidCallparking,
    /// `invalid_callrecording` — This is not a valid Call recording
    InvalidCallrecording,
    /// `invalid_call_type` — Call Type is not valid.
    InvalidCallType,
    /// `invalid_canada_routing` — This is not a valid Canada Route
    InvalidCanadaRouting,
    /// `invalid_carrier` — This is not a valid Carrier
    InvalidCarrier,
    /// `invalid_charge` — This is not a valid Charge
    InvalidCharge,
    /// `invalid_city` — City is missing or the format is invalid.
    InvalidCity,
    /// `invalid_client` — This is not a valid Client
    InvalidClient,
    /// `invalid_cnam` — This is not a valid CNAM Should be: 1/0
    InvalidCNAM,
    /// `invalid_codec` — This is not a valid Codec
    InvalidCodec,
    /// `invalid_conference` — This is not a valid Conference ID
    InvalidConference,
    /// `invalid_contact` — This is not a valid Contact Number
    InvalidContact,
    /// `invalid_country` — Country is missing or the format is invalid, must be in format ISO 3166-1 alpha-2, example: US, CA, etc. (You can use the values returned by the method getCountries)
    InvalidCountry,
    /// `invalid_countryid` — This is not a valid Country ID
    InvalidCountryid,
    /// `invalid_credentials` — Username or Password is incorrect
    InvalidCredentials,
    /// `invalid_date` — This is not a valid date Format is: yyyy-mm-dd
    InvalidDate,
    /// `invalid_daterange` — Date Range should be 92 days or less
    InvalidDaterange,
    /// `invalid_datetime` — This is not a valid datetime Format is: yyyy-mm-dd hh:mm:ss
    InvalidDatetime,
    /// `invalid_date_from` — The "From" date should be prior to the "To" date.
    InvalidDateFrom,
    /// `invalid_dayrange` — This is not a valid Day Range
    InvalidDayrange,
    /// `invalid_delay_before` — This is not a valid DelayBefore
    InvalidDelayBefore,
    /// `invalid_deletemessage` — This is not a valid DeleteMessage Should be: yes/no
    InvalidDeletemessage,
    /// `invalid_description` — This is not a valid Description
    InvalidDescription,
    /// `invalid_destination` — This is not a valid Destination
    InvalidDestination,
    /// `invalid_destination_folder` — This is not a valid Destination Folder
    InvalidDestinationFolder,
    /// `invalid_devicetype` — This is not a valid Device Type
    InvalidDevicetype,
    /// `invalid_dialtime` — This is not a valid Dialtime
    InvalidDialtime,
    /// `invalid_did` — This is not a valid DID
    InvalidDID,
    /// `invalid_digits` — These are not valid DigitsOrderDIDVirtual: Digits must be 3 numbers
    InvalidDigits,
    /// `invalid_digit_timeout` — This is not a valid DigitTimeOut
    InvalidDigitTimeout,
    /// `invalid_disa` — This is not a valid DISA
    InvalidDISA,
    /// `invalid_diversion_header` — This is not a valid Diversion Header. It must be a numeric value, accepting only 0 or 1.
    InvalidDiversionHeader,
    /// `invalid_drop_silence` — This is not a valid "drop silence" value
    InvalidDropSilence,
    /// `invalid_dst` — This is not a valid Destination Number
    InvalidDST,
    /// `invalid_dtmfmode` — This is no a valid DTMF Mode
    InvalidDtmfmode,
    /// `invalid_dtmf_digits` — This is no a valid DTMF digit
    InvalidDTMFDigits,
    /// `invalid_email` — This is not a valid email or email is already in database
    InvalidEmail,
    /// `invalid_email_attachment_format` — This is not a valid format value
    InvalidEmailAttachmentFormat,
    /// `invalid_email_enable` — This is not a valid email enable value
    InvalidEmailEnable,
    /// `invalid_enable_ip_restriction` — This is not a valid Enable IP Restriction value
    InvalidEnableIPRestriction,
    /// `invalid_enable_pop_restriction` — This is not a valid Enable POP Restriction value
    InvalidEnablePOPRestriction,
    /// `invalid_endhour` — This is not a valid End Hour
    InvalidEndhour,
    /// `invalid_endminute` — This is not a valid End Minute
    InvalidEndminute,
    /// `invalid_extension` — This is not a valid extension Extension can only contain digits
    InvalidExtension,
    /// `invalid_extensions` — Extensions cannot be: 098, 211, 311, 411, 4443, 4444, 4747, 511, 711, 811, 822, 911, 988
    InvalidExtensions,
    /// `invalid_extension_length` — Extensions should not contain more than 5 digits
    InvalidExtensionLength,
    /// `invalid_extension_prefix` — Extensions cannot start with: 068, 097
    InvalidExtensionPrefix,
    /// `invalid_failover_header` — This is not a valid failover header Should be: account/vm/fwd/none
    InvalidFailoverHeader,
    /// `invalid_fax_id` — This is not a valid Fax Message ID
    InvalidFAXID,
    /// `invalid_file` — This is not a valid File
    InvalidFile,
    /// `invalid_filter` — This is not a valid Filter
    InvalidFilter,
    /// `invalid_firstname` — First name is missing or the format is invalid.
    InvalidFirstname,
    /// `invalid_foc_enddate` — Invalid date format, must be: YYYY-mm-dd. Example: 2018-02-22
    InvalidFocEnddate,
    /// `invalid_foc_startdate` — Invalid date format, must be: YYYY-mm-dd. Example: 2018-02-22
    InvalidFocStartdate,
    /// `invalid_folder` — This is not a valid Folder
    InvalidFolder,
    /// `invalid_folder_id` — This is not a valid Fax Folder ID
    InvalidFolderID,
    /// `invalid_forwarding` — This is not a valid forwarding
    InvalidForwarding,
    /// `invalid_forwarding_did` — Forwarding to the same did is not allowed
    InvalidForwardingDID,
    /// `invalid_forward_enable` — This is not a valid forward enable value
    InvalidForwardEnable,
    /// `invalid_frequency_announcement` — This is not a valid Frequency announce
    InvalidFrequencyAnnouncement,
    /// `invalid_from_number` — This is not a valid sender number.
    InvalidFromNumber,
    /// `invalid_fullname` — This is not a valid Full Name
    InvalidFullname,
    /// `invalid_id` — This is not a valid ID
    InvalidID,
    /// `invalid_if_announce_position_enabled_report_e` — This is not a Report estimated hold time type
    InvalidIfAnnouncePositionEnabledReportE,
    /// `invalid_internaldialtime` — This is not a valid Internal Dialtime Should be: 1 to 60
    InvalidInternaldialtime,
    /// `invalid_internalvoicemail` — This is not a valid Internal Voicemail
    InvalidInternalvoicemail,
    /// `invalid_internationalroute` — This is not a valid International Route
    InvalidInternationalroute,
    /// `invalid_invoice_type` — Invalid invoice type, possible values: 0 = US, 1 = CAN.
    InvalidInvoiceType,
    /// `invalid_ip` — This is an invalid IP
    InvalidIP,
    /// `invalid_ip_auth` — Do not provide an IP address for User/Pass Authentication
    InvalidIPAuth,
    /// `invalid_ip_iax2` — Do not provide an IP address for IAX2
    InvalidIPIax2,
    /// `invalid_ivr` — This is not a valid IVR
    InvalidIVR,
    /// `invalid_jitter_buffer` — This is not a valid "jitter buffer" value
    InvalidJitterBuffer,
    /// `invalid_join_announcement` — This is not a valid 'Join Announcement' Type for a Queue
    InvalidJoinAnnouncement,
    /// `invalid_join_empty_type` — This is not a valid 'JoinWhenEmpty' Type for a Queue
    InvalidJoinEmptyType,
    /// `invalid_language` — This is not a valid Language Should be: es/en/fr
    InvalidLanguage,
    /// `invalid_lastname` — Lastname is missing or the format is invalid.
    InvalidLastname,
    /// `invalid_listened` — This is not a valid Listened value
    InvalidListened,
    /// `invalid_location` — This is not a valid Location
    InvalidLocation,
    /// `invalid_lockinternational` — This is not a valid Lock International
    InvalidLockinternational,
    /// `invalid_mailbox` — This is not a valid mailbox
    InvalidMailbox,
    /// `invalid_maximum_callers` — This is not a valid maximum callers value
    InvalidMaximumCallers,
    /// `invalid_maximum_wait_time` — This is not a valid maximum wait time value
    InvalidMaximumWaitTime,
    /// `invalid_max_expiry` — This is not a valid Max Expiry (value must be between 60 and 3600 seconds)
    InvalidMaxExpiry,
    /// `invalid_member` — This is not a valid Member
    InvalidMember,
    /// `invalid_member_delay` — This is not a valid Member Delay
    InvalidMemberDelay,
    /// `invalid_message_num` — This is not a valid Voicemail Message Number
    InvalidMessageNum,
    /// `invalid_method` — This is not a valid Method
    InvalidMethod,
    /// `invalid_minute` — This is not a valid Minute Rate
    InvalidMinute,
    /// `invalid_mixed_numbers` — Toll-free numbers and local numbers can not be mixed in the same order.
    InvalidMixedNumbers,
    /// `invalid_monthly` — This is not a valid Montly Fee
    InvalidMonthly,
    /// `invalid_musiconhold` — This is not a valid Music on Hold
    InvalidMusiconhold,
    /// `invalid_name` — This is not a valid name, Alphanumeric Only
    InvalidName,
    /// `invalid_nat` — This is not a valid NAT
    InvalidNAT,
    /// `invalid_note` — This is not a valid Note, lenght should be less than 50 chars
    InvalidNote,
    /// `invalid_number` — This is not a valid Number
    InvalidNumber,
    /// `invalid_numbermembers` — The element format of multiple data is not correct or it size does not match with other elements
    InvalidNumbermembers,
    /// `invalid_number_canadian` — You have entered a Canadian number (not valid in this portability process).
    InvalidNumberCanadian,
    /// `invalid_number_exist` — The number is already in our network
    InvalidNumberExist,
    /// `invalid_number_fax` — The Fax number can not be ported into our network
    InvalidNumberFAX,
    /// `invalid_number_porttype` — You have entered a local number (not valid in this portability process)
    InvalidNumberPorttype,
    /// `invalid_number_us` — You have entered a USA number (not valid in this portability process).
    InvalidNumberUS,
    /// `invalid_order` — This is not a valid "order" value
    InvalidOrder,
    /// `invalid_package` — This is not a valid Package
    InvalidPackage,
    /// `invalid_password` — This is not a valid passwordVoicemail: Must be 4 Digits SubAccounts: More than 6 chars, Must Contain Alphanumeric and !#$%&/()=?*[]_:.,{}+-
    InvalidPassword,
    /// `invalid_password_auth` — Do not provide a Password for IP Authentication
    InvalidPasswordAuth,
    /// `invalid_password_ilegal_characters` — This is not a valid password (Allowed characters: Alphanumeric and ! # $ % & / ( ) = ? * [ ] _ : . , { } + -)
    InvalidPasswordIlegalCharacters,
    /// `invalid_password_lessthan_8characters_long` — This is not a valid password (Less than 8 characters long)
    InvalidPasswordLessthan8charactersLong,
    /// `invalid_password_missing_lowercase` — This is not a valid password (Missing lower case character)
    InvalidPasswordMissingLowercase,
    /// `invalid_password_missing_number` — This is not a valid password (Missing a number)
    InvalidPasswordMissingNumber,
    /// `invalid_password_missing_uppercase` — This is not a valid password (Missing upper case character)
    InvalidPasswordMissingUppercase,
    /// `invalid_pause` — This is not a valid Pause
    InvalidPause,
    /// `invalid_payment` — This is not a valid Payment
    InvalidPayment,
    /// `invalid_phonebook` — This is not a valid Phonebook
    InvalidPhonebook,
    /// `invalid_phonenumber` — This is not a valid Phone Number
    InvalidPhonenumber,
    /// `invalid_pin` — This is not a valid PIN
    InvalidPIN,
    /// `invalid_pin_number` — Must provide the account PIN number.
    InvalidPINNumber,
    /// `invalid_playinstructions` — This is not a valid PlayInstructions Should be: u/su
    InvalidPlayinstructions,
    /// `invalid_pop_restriction` — This is not a valid POP Restriction
    InvalidPOPRestriction,
    /// `invalid_portingid` — The given ID is invalid or doesn't exist.
    InvalidPortingid,
    /// `invalid_porttype` — Must provide a valid port type.
    InvalidPorttype,
    /// `invalid_port_status` — The status code is invalid. (You can use the values returned by the method getListStatus)
    InvalidPortStatus,
    /// `invalid_priority` — This is not a valid Priority
    InvalidPriority,
    /// `invalid_priority_weight` — This is not valid weight/priority value
    InvalidPriorityWeight,
    /// `invalid_protocol` — This is not a valid Protocol
    InvalidProtocol,
    /// `invalid_provider_account` — You must provide your account # with the current provider
    InvalidProviderAccount,
    /// `invalid_provider_name` — You must provide the service provider name
    InvalidProviderName,
    /// `invalid_province` — This is not a valid Province
    InvalidProvince,
    /// `invalid_quantity` — This is not a valid quantity
    InvalidQuantity,
    /// `invalid_query` — This is not a valid Query
    InvalidQuery,
    /// `invalid_queue` — This is not a valid Queue
    InvalidQueue,
    /// `invalid_quiet` — This is not a valid "quiet" value
    InvalidQuiet,
    /// `invalid_recording` — This is not a valid recording
    InvalidRecording,
    /// `invalid_recording_sound_error_menu` — "error menu" is not a valid recording
    InvalidRecordingSoundErrorMenu,
    /// `invalid_recording_sound_get_pin` — "get pin" is not a valid recording
    InvalidRecordingSoundGetPIN,
    /// `invalid_recording_sound_has_joined` — "has_joined" is not a valid recording
    InvalidRecordingSoundHasJoined,
    /// `invalid_recording_sound_has_left` — "has_left" is not a valid recording
    InvalidRecordingSoundHasLeft,
    /// `invalid_recording_sound_invalid_pin` — "invalid pin" is not a valid recording
    InvalidRecordingSoundInvalidPIN,
    /// `invalid_recording_sound_join` — "join" is not a valid recording
    InvalidRecordingSoundJoin,
    /// `invalid_recording_sound_kicked` — "kicked" is not a valid recording
    InvalidRecordingSoundKicked,
    /// `invalid_recording_sound_leave` — "leave" is not a valid recording
    InvalidRecordingSoundLeave,
    /// `invalid_recording_sound_locked` — "locked" is not a valid recording
    InvalidRecordingSoundLocked,
    /// `invalid_recording_sound_locked_now` — "locked now" is not a valid recording
    InvalidRecordingSoundLockedNow,
    /// `invalid_recording_sound_muted` — "muted" is not a valid recording
    InvalidRecordingSoundMuted,
    /// `invalid_recording_sound_only_one` — "only one" is not a valid recording
    InvalidRecordingSoundOnlyOne,
    /// `invalid_recording_sound_only_person` — "only person" is not a valid recording
    InvalidRecordingSoundOnlyPerson,
    /// `invalid_recording_sound_other_in_party` — "other in party" is not a valid recording
    InvalidRecordingSoundOtherInParty,
    /// `invalid_recording_sound_participants_muted` — "participants muted" is not a valid recording
    InvalidRecordingSoundParticipantsMuted,
    /// `invalid_recording_sound_participants_unmuted` — "participants unmuted" is not a valid recording
    InvalidRecordingSoundParticipantsUnmuted,
    /// `invalid_recording_sound_place_into_conference` — "place into conference" is not a valid recording
    InvalidRecordingSoundPlaceIntoConference,
    /// `invalid_recording_sound_there_are` — "there are" is not a valid recording
    InvalidRecordingSoundThereAre,
    /// `invalid_recording_sound_unlocked_now` — "unlocked now" is not a valid recording
    InvalidRecordingSoundUnlockedNow,
    /// `invalid_recording_sound_unmuted` — "unmuted" is not a valid recording
    InvalidRecordingSoundUnmuted,
    /// `invalid_record_calls` — Record calls is not valid.
    InvalidRecordCalls,
    /// `invalid_report_hold_time_agent` — This is not a valid Report hold time agent
    InvalidReportHoldTimeAgent,
    /// `invalid_resellerclient` — This is not a valid Reseller Client
    InvalidResellerclient,
    /// `invalid_resellernextbilling` — This is not a valid Reseller Next Billing date, date should not be set in the past.
    InvalidResellernextbilling,
    /// `invalid_resellerpackage` — This is not a valid Reseller Package
    InvalidResellerpackage,
    /// `invalid_response_timeout` — This is not a valid ResponseTimeOut
    InvalidResponseTimeout,
    /// `invalid_retry_timer` — This is not a valid Retry timer
    InvalidRetryTimer,
    /// `invalid_ringgroup` — This is not a valid Ring group
    InvalidRinggroup,
    /// `invalid_ring_inuse` — This is not a valid Ring in use value
    InvalidRingInuse,
    /// `invalid_route` — This is not a valid Route
    InvalidRoute,
    /// `invalid_routing_header` — This is not a valid Routing header Should be: account/vm/fwd
    InvalidRoutingHeader,
    /// `invalid_rtp_hold_timeout` — This is not a valid RTP Hold Time Out (value must be between 1 and 3600 seconds)
    InvalidRTPHoldTimeout,
    /// `invalid_rtp_timeout` — This is not a valid RTP Time Out (value must be between 1 and 3600 seconds)
    InvalidRTPTimeout,
    /// `invalid_saycallerid` — This is not a valid SayCallerID Should be: yes/no
    InvalidSaycallerid,
    /// `invalid_saytime` — This is not a valid SayTime Should be: yes/no
    InvalidSaytime,
    /// `invalid_security_code` — This is not a valid Security Code. Should be alphanumeric.
    InvalidSecurityCode,
    /// `invalid_serverpop` — This is not a valid Server POP
    InvalidServerpop,
    /// `invalid_setup` — This is not a valid Setup Fee
    InvalidSetup,
    /// `invalid_silence_threshold` — This is not a valid "silence threshold" value
    InvalidSilenceThreshold,
    /// `invalid_sipuri` — This is not a valid SIPURI
    InvalidSIPURI,
    /// `invalid_sip_traffic` — This is not a valid Encrypted SIP Traffic value
    InvalidSIPTraffic,
    /// `invalid_skippassword` — This is not a valid skippassword Should be: 1/0 - or - yes/no
    InvalidSkippassword,
    /// `invalid_smpp_password` — This is not a valid SMPP Password
    InvalidSmppPassword,
    /// `invalid_smpp_url` — This is not a valid SMPP URL
    InvalidSmppURL,
    /// `invalid_smpp_username` — This is not a valid SMPP Username
    InvalidSmppUsername,
    /// `invalid_sms` — This is not a valid SMS
    InvalidSMS,
    /// `invalid_sms_forward` — This is not a valid SMS forward
    InvalidSMSForward,
    /// `invalid_snn` — Must provide the 4 last digits of the SSN.
    InvalidSnn,
    /// `invalid_speed_dial` — This is not a valid Speed Dial
    InvalidSpeedDial,
    /// `invalid_starthour` — This is not a valid Start Hour
    InvalidStarthour,
    /// `invalid_startminute` — This is not a valid Start Minute
    InvalidStartminute,
    /// `invalid_start_muted` — This is not a valid Start Muted
    InvalidStartMuted,
    /// `invalid_state` — This is not a valid State
    InvalidState,
    /// `invalid_statement_name` — Statement Name is missing or the format is invalid.
    InvalidStatementName,
    /// `invalid_strategy` — This is not a valid Ring Strategy
    InvalidStrategy,
    /// `invalid_street_name` — This is not a valid Street Name
    InvalidStreetName,
    /// `invalid_street_number` — This is not a valid Street Number
    InvalidStreetNumber,
    /// `invalid_talking_threshold` — This is not a valid "talking threshold" value
    InvalidTalkingThreshold,
    /// `invalid_talk_detection` — This is not a valid talk detection value
    InvalidTalkDetection,
    /// `invalid_tfnumber_porttype` — You have entered a toll-free number (not valid in this portability process).
    InvalidTfnumberPorttype,
    /// `invalid_thankyou_for_your_patience` — This is not a valid Thankyou for your patience value
    InvalidThankyouForYourPatience,
    /// `Invalid_threshold` — This is not a valid Threshold Amount. The Threshold Amount should be between 1 and 250
    InvalidThreshold,
    /// `invalid_timecondition` — This is not a valid Time Condition
    InvalidTimecondition,
    /// `invalid_timeout` — This is not a valid timeout
    InvalidTimeout,
    /// `invalid_timerange` — This is not a valid Timer Range
    InvalidTimerange,
    /// `invalid_timezone` — This is not a valid TimezoneCDR and resellerCDR: Must be numeric Voicemail: Values from getTimezone
    InvalidTimezone,
    /// `invalid_to_number` — This is not a valid destination number
    InvalidToNumber,
    /// `invalid_transcription_email` — Transcription email is not valid
    InvalidTranscriptionEmail,
    /// `invalid_transcription_format` — Invalid Transcription Format
    InvalidTranscriptionFormat,
    /// `invalid_transcription_locale` — Transcription locale is not valid.
    InvalidTranscriptionLocale,
    /// `invalid_transcription_redaction` — Invalid Transcription Redaction
    InvalidTranscriptionRedaction,
    /// `invalid_transcription_sentiment` — Invalid Transcription Sentiment
    InvalidTranscriptionSentiment,
    /// `invalid_transcription_summary` — Invalid Transcription Summary
    InvalidTranscriptionSummary,
    /// `invalid_type` — This is not a valid Type
    InvalidType,
    /// `invalid_urgent` — This is not valid urgent value
    InvalidUrgent,
    /// `invalid_username` — This is not a valid Username
    InvalidUsername,
    /// `invalid_voicemailsetup` — This is not a valid voicemail
    InvalidVoicemailsetup,
    /// `invalid_voice_announcement` — This is not a valid Voice announce
    InvalidVoiceAnnouncement,
    /// `invalid_weekdayend` — This is not a valid Week End
    InvalidWeekdayend,
    /// `invalid_weekdaystart` — This is not a valid Week Start
    InvalidWeekdaystart,
    /// `invalid_wrapup_time` — This is not a valid Wrapup time
    InvalidWrapupTime,
    /// `invalid_zip` — Zip Code is missing or the format is invalid.
    InvalidZip,
    /// `ip_not_enabled` — This IP is not enabled for API use
    IPNotEnabled,
    /// `limit_reached` — You have reached the maximum number of messages allowed per day. - SMS limit using the API. - Fax limit applies using any method.
    LimitReached,
    /// `location_already_exists` — A location with this name already exists
    LocationAlreadyExists,
    /// `location_linked_to_subaccount` — This location is in use by one or more sub accounts and cannot be deleted
    LocationLinkedToSubaccount,
    /// `location_not_found` — The specified location could not be found
    LocationNotFound,
    /// `max_phonebook` — Your account is limited to 8 SIP, IAX or SIP URI members
    MaxPhonebook,
    /// `members_exceeded` — You have reached the maximum allowed entries for the Phonebook
    MembersExceeded,
    /// `member_already_included` — The member has been included already
    MemberAlreadyIncluded,
    /// `message_empty` — The SMS Message is empty
    MessageEmpty,
    /// `message_not_found` — The voicemail message was not found
    MessageNotFound,
    /// `method_maintenance` — This API method is under maintenance
    MethodMaintenance,
    /// `mismatch_email_confirm` — e-mail confirm does not match with e-mail
    MismatchEmailConfirm,
    /// `mismatch_password_confirm` — Pasword confirm does not match with Password
    MismatchPasswordConfirm,
    /// `missing_account` — Account was not provided
    MissingAccount,
    /// `missing_address` — Address was not provided
    MissingAddress,
    /// `missing_agent_ring_timeout` — Agent ring time out was not provided
    MissingAgentRingTimeout,
    /// `missing_allowedcodecs` — Allowed Codecs were not provided
    MissingAllowedcodecs,
    /// `missing_attachmessage` — AttachMessage was not provided
    MissingAttachmessage,
    /// `missing_authtype` — Auth Type was not provided
    MissingAuthtype,
    /// `missing_balancemanagement` — BalanceManagemente was not provided
    MissingBalancemanagement,
    /// `missing_billingtype` — Billing Type was not provided
    MissingBillingtype,
    /// `missing_callback` — Callback was not provided
    MissingCallback,
    /// `missing_callerid` — CallerID was not provided
    MissingCallerid,
    /// `missing_callhunting` — Call hunting was not provided
    MissingCallhunting,
    /// `missing_callparking` — Call Parking was not provided
    MissingCallparking,
    /// `missing_callrecording` — Call recording was not provided
    MissingCallrecording,
    /// `missing_carrier` — Carrier was not provided
    MissingCarrier,
    /// `missing_charge` — Charge was not provided.
    MissingCharge,
    /// `missing_choices` — Choices was not provided
    MissingChoices,
    /// `missing_city` — City was not provided
    MissingCity,
    /// `missing_client` — Client was not provided
    MissingClient,
    /// `missing_cnam` — CNAM was not provided
    MissingCNAM,
    /// `missing_codec` — Codec was not provided
    MissingCodec,
    /// `missing_conference` — Conference was not provided
    MissingConference,
    /// `missing_country` — Country was not provided
    MissingCountry,
    /// `missing_countryid` — Country ID was not provided
    MissingCountryid,
    /// `missing_credentials` — Username or Password was not provided
    MissingCredentials,
    /// `missing_datetime` — DateTime value was not provided
    MissingDatetime,
    /// `missing_delay_before` — DelayBefore was not provided
    MissingDelayBefore,
    /// `missing_deletemessage` — DeleteMessage was not provided
    MissingDeletemessage,
    /// `missing_description` — Description was not provided
    MissingDescription,
    /// `missing_devicetype` — Device Type was not provided
    MissingDevicetype,
    /// `missing_dialtime` — Dialtime was not provided
    MissingDialtime,
    /// `missing_did` — DID was not provided
    MissingDID,
    /// `missing_digits` — Digits were not provided
    MissingDigits,
    /// `missing_digit_timeout` — DigitTimeOut was not provided
    MissingDigitTimeout,
    /// `missing_disa` — DISA was not provided
    MissingDISA,
    /// `missing_dtmfmode` — DTMF Mode was not provided
    MissingDtmfmode,
    /// `missing_email` — e-mail was not provided
    MissingEmail,
    /// `missing_email_confirm` — e-mail confirm was not provided
    MissingEmailConfirm,
    /// `missing_enable` — Enable was not provided
    MissingEnable,
    /// `missing_endhour` — End Hour was not provided
    MissingEndhour,
    /// `missing_endminute` — End Minute was not provided
    MissingEndminute,
    /// `missing_failover_busy` — Failover Busy was not provided
    MissingFailoverBusy,
    /// `missing_failover_noanswer` — Failover NoAnswer was not provided
    MissingFailoverNoanswer,
    /// `missing_failover_unreachable` — Failover Unreachable was not provided
    MissingFailoverUnreachable,
    /// `missing_file` — File was not provided
    MissingFile,
    /// `missing_filter` — Filter was not provided
    MissingFilter,
    /// `missing_firstname` — Firstname was not provided
    MissingFirstname,
    /// `missing_folder` — folder was not provided
    MissingFolder,
    /// `missing_forwarding` — Forwarding was not provided
    MissingForwarding,
    /// `missing_from_date` — From date was not provided
    MissingFromDate,
    /// `missing_fullname` — Full Name was not provided
    MissingFullname,
    /// `missing_id` — ID was not provided
    MissingID,
    /// `missing_if_announce_position_enabled_report_e` — If announce position enabled report estimated hold time' type was not provided
    MissingIfAnnouncePositionEnabledReportE,
    /// `missing_internationalroute` — International Route was not provided
    MissingInternationalroute,
    /// `missing_ip` — You need to provide an IP if you select IP Authentication Method
    MissingIP,
    /// `missing_ip_h323` — You must enter an IP Address for H.323
    MissingIPH323,
    /// `missing_ip_restriction` — IP Restriction was not provided
    MissingIPRestriction,
    /// `missing_ivr` — IVR was not provided
    MissingIVR,
    /// `missing_join_when_empty` — JoinWhenEmpty' type was not provided
    MissingJoinWhenEmpty,
    /// `missing_language` — Language was not provided
    MissingLanguage,
    /// `missing_lastname` — Lastname was not provided
    MissingLastname,
    /// `missing_leave_when_empty` — LeaveWhenEmpty' type was not provided
    MissingLeaveWhenEmpty,
    /// `missing_length` — Length was not provided
    MissingLength,
    /// `missing_listened` — Listened code was not provided
    MissingListened,
    /// `missing_location` — Location was not provided
    MissingLocation,
    /// `missing_location_name` — Location Name Missing
    MissingLocationName,
    /// `missing_lockinternational` — Lock International was not provided
    MissingLockinternational,
    /// `missing_mailbox` — Mailbox was not provided
    MissingMailbox,
    /// `missing_member` — Member was not provided
    MissingMember,
    /// `missing_members` — You need at least 1 member to create a ring group
    MissingMembers,
    /// `missing_message_num` — Voicemail message number was not provided
    MissingMessageNum,
    /// `missing_method` — Method must be provided when using the REST/JSON API
    MissingMethod,
    /// `missing_minute` — Minute Rate was not provided
    MissingMinute,
    /// `missing_monthly` — Monthly Fee was not provided
    MissingMonthly,
    /// `missing_musiconhold` — Music on Hold was not provided
    MissingMusiconhold,
    /// `missing_name` — Name was not provided
    MissingName,
    /// `missing_nat` — NAT was not provided
    MissingNAT,
    /// `missing_number` — Number was not provided
    MissingNumber,
    /// `missing_numbers` — You must enter at least one valid phone number.
    MissingNumbers,
    /// `missing_package` — Package was not provided
    MissingPackage,
    /// `missing_params` — Required parameters were not provided
    MissingParams,
    /// `missing_password` — Password was not provided
    MissingPassword,
    /// `missing_password_confirm` — Password Confirm was not provided
    MissingPasswordConfirm,
    /// `missing_payment` — Payment was not provided.
    MissingPayment,
    /// `missing_phonebook` — Phonebook was not provided
    MissingPhonebook,
    /// `missing_phonenumber` — Phone Number was not provided
    MissingPhonenumber,
    /// `missing_pin` — PIN was not provided
    MissingPIN,
    /// `missing_playinstructions` — PlayInstructions was not provided
    MissingPlayinstructions,
    /// `missing_pop_restriction` — POP Restriction was not provided
    MissingPOPRestriction,
    /// `missing_priority` — Priority was not provided
    MissingPriority,
    /// `missing_priority_weight` — Priority/Weight was not provided
    MissingPriorityWeight,
    /// `missing_protocol` — Protocol was not provided
    MissingProtocol,
    /// `missing_province` — Province was not provided
    MissingProvince,
    /// `missing_query` — Query was not provided
    MissingQuery,
    /// `missing_recording` — Recording was not provided
    MissingRecording,
    /// `missing_report_hold_time_agent` — Report hold time agent was not provided
    MissingReportHoldTimeAgent,
    /// `missing_resellerclient` — Provide a Reseller Client or don't provide a Reseller Package
    MissingResellerclient,
    /// `missing_resellerpackage` — Provide a Reseller Package or don't provide a Reseller Client
    MissingResellerpackage,
    /// `missing_response_timeout` — ResponseTimeOut was not provided
    MissingResponseTimeout,
    /// `missing_ringgroup` — Ring group was not provided
    MissingRinggroup,
    /// `missing_ring_inuse` — Ring in use was not provided
    MissingRingInuse,
    /// `missing_ring_strategy` — Ring strategy was not provided
    MissingRingStrategy,
    /// `missing_route` — Route was not provided
    MissingRoute,
    /// `missing_routing` — Routing was not provided
    MissingRouting,
    /// `missing_saycallerid` — SayCallerID was not provided
    MissingSaycallerid,
    /// `missing_saytime` — SayTime was not provided
    MissingSaytime,
    /// `missing_serverpop` — Server POP was not provided
    MissingServerpop,
    /// `missing_setup` — Setup Fee was not provided
    MissingSetup,
    /// `missing_sipuri` — SIPURI was not provided
    MissingSIPURI,
    /// `missing_skippassword` — SkipPassword was not provided
    MissingSkippassword,
    /// `missing_sms` — SMS was not provided
    MissingSMS,
    /// `missing_speed_dial` — Speed Dial was not provided
    MissingSpeedDial,
    /// `missing_start` — Start date was not provided
    MissingStart,
    /// `missing_starthour` — Start Hour was not provided
    MissingStarthour,
    /// `missing_startminute` — Start Minute was not provided
    MissingStartminute,
    /// `missing_state` — State was not provided
    MissingState,
    /// `missing_street_name` — Street Name was not provided
    MissingStreetName,
    /// `missing_street_number` — Street Number was not provided
    MissingStreetNumber,
    /// `missing_thankyou_for_your_patience` — Thankyou for your patience was not provided
    MissingThankyouForYourPatience,
    /// `missing_timecondition` — Time Condition was not provided
    MissingTimecondition,
    /// `missing_timeout` — Timeout was not provided
    MissingTimeout,
    /// `missing_timezone` — Timezone was not provided
    MissingTimezone,
    /// `missing_to_date` — To date was not provided
    MissingToDate,
    /// `missing_transcription_email` — Transcription email is required.
    MissingTranscriptionEmail,
    /// `missing_transcription_locale` — Transcription locale is required.
    MissingTranscriptionLocale,
    /// `missing_type` — Type was not provided
    MissingType,
    /// `missing_urgent` — Urgent code was not provided
    MissingUrgent,
    /// `missing_uri` — URI was not provided
    MissingURI,
    /// `missing_username` — Username was not provided
    MissingUsername,
    /// `missing_voicemailsetup` — Voice mail setup was not provided
    MissingVoicemailsetup,
    /// `missing_weekdayend` — Week End was not provide
    MissingWeekdayend,
    /// `missing_weekdaystart` — Week Start was not provided
    MissingWeekdaystart,
    /// `missing_zip` — Zip Code was not provided
    MissingZip,
    /// `moving_fail` — The Fax Message was not moved
    MovingFail,
    /// `name_toolong` — The name exceeds character size limit
    NameToolong,
    /// `non_sufficient_funds` — Your account does not have sufficient funds to proceed
    NonSufficientFunds,
    /// `note_toolong` — The note exceeds character size limit
    NoteToolong,
    /// `no_account` — There are no accounts
    NoAccount,
    /// `no_attachments` — Theres no attachments records to show.
    NoAttachments,
    /// `no_base64file` — File not encoded in base64
    NoBase64file,
    /// `no_callback` — There are not Callbacks
    NoCallback,
    /// `no_callhunting` — There are no Call Huntings
    NoCallhunting,
    /// `no_callparking` — There are no Call Parking
    NoCallparking,
    /// `no_callstatus` — No Call Status was provided. One of the following parameters needs to be set to "1": answered, noanswer, busy, failed
    NoCallstatus,
    /// `no_cdr` — There are no CDR entries for the filter
    NoCDR,
    /// `no_change_billingtype` — Imposible change DID billing plan
    NoChangeBillingtype,
    /// `no_client` — There are no Clients
    NoClient,
    /// `no_conference` — There are no Conferences
    NoConference,
    /// `no_did` — There are no DIDs
    NoDID,
    /// `no_disa` — There are no DISAs
    NoDISA,
    /// `no_emailtofax` — There are no Email to Fax entries
    NoEmailtofax,
    /// `no_filter` — There are no Filters
    NoFilter,
    /// `no_folder` — There are no Fax Folders
    NoFolder,
    /// `no_forwarding` — There was no Forwarding
    NoForwarding,
    /// `no_ivr` — There are no ivr
    NoIVR,
    /// `no_mailbox` — There are no Mailboxes
    NoMailbox,
    /// `no_member` — There are no Static Members
    NoMember,
    /// `no_message` — There are no Fax Message(s)
    NoMessage,
    /// `no_messages` — There are no Voicemail Message(s)
    NoMessages,
    /// `no_numbers` — There are no Fax Numbers
    NoNumbers,
    /// `no_package` — there are no Packages
    NoPackage,
    /// `no_phonebook` — There are no Phonebook entries
    NoPhonebook,
    /// `no_phonebook_group` — There are no Phonebook Groups
    NoPhonebookGroup,
    /// `no_provision` — E911 service wasn't activated, this response comes with a description of the error.
    NoProvision,
    /// `no_provision_update` — E911 service wasn't updated, this response comes with a description of the error.
    NoProvisionUpdate,
    /// `no_queue` — There are no Queue entries
    NoQueue,
    /// `no_rate` — There are no Rates
    NoRate,
    /// `no_recording` — There are no recordings
    NoRecording,
    /// `no_ringgroup` — There are no Ring groups
    NoRinggroup,
    /// `no_sequences` — No sequence has been found
    NoSequences,
    /// `no_sipuri` — There are no SIP URIs
    NoSIPURI,
    /// `no_sms` — There are no SMS messages
    NoSMS,
    /// `no_timecondition` — There are no Time Conditions
    NoTimecondition,
    /// `no_transactions` — There are no transactions
    NoTransactions,
    /// `no_vpri` — There are no vPRIs
    NoVPRI,
    /// `order_failed` — The order wasn't completed.
    OrderFailed,
    /// `problem_sending_mail` — There was a problem sending an email.
    ProblemSendingMail,
    /// `provider_outofservice` — One of our providers is out of service
    ProviderOutofservice,
    /// `recording_in_use_caller_id_filtering` — You have a Caller ID Filtering using this Recording
    RecordingInUseCallerIDFiltering,
    /// `recording_in_use_caller_timecondition` — You have a Time Condition using this Recording
    RecordingInUseCallerTimecondition,
    /// `recording_in_use_did` — You have a DID using this Recording
    RecordingInUseDID,
    /// `recording_in_use_ivr` — You have an IVR using this Recording
    RecordingInUseIVR,
    /// `recording_in_use_queue` — You have a Calling Queue using this Recording
    RecordingInUseQueue,
    /// `repeated_ip` — You already have a Subaccount using this IP and Protocol
    RepeatedIP,
    /// `reserved_ip` — This is a reserved IP used by VoIP.ms or other Companies
    ReservedIP,
    /// `rtp_timeout_greater_than_rtp_hold_timeout` — RTP Time Out can't be greater than RTP Hold Time Out
    RTPTimeoutGreaterThanRTPHoldTimeout,
    /// `same_did_billingtype` — The Billing Type provided and DID billing type are the same
    SameDIDBillingtype,
    /// `sent_fail` — The Fax Message it wasn't send.
    SentFail,
    /// `sipuri_in_phonebook` — This SIPURI can't be deleted, it is mapped in the phonebook
    SIPURIInPhonebook,
    /// `sms_apply_regulations` — The number was not updated due to SMS regulations, please contact customer service for more information
    SMSApplyRegulations,
    /// `sms_failed` — The SMS message was not sent
    SMSFailed,
    /// `sms_toolong` — The SMS message exceeds 160 characters
    SMSToolong,
    /// `sms_wait_message` — SMS was not (Enabled/Disabled) for this DID, please wait a minute before you try again.
    SMSWaitMessage,
    /// `tls_error` — Theres was a TLS error, please try later.
    TlsError,
    /// `Unable_to_purchase` — Unable to purchase DIDs
    UnableToPurchase,
    /// `unavailable_info` — The information you requested is unavailable at this moment
    UnavailableInfo,
    /// `unsifficient_stock` — Theres no sufficient stock to complete the order.
    UnsifficientStock,
    /// `used_description` — You already have a record with this Description
    UsedDescription,
    /// `used_email` — You already have an entry with this Email
    UsedEmail,
    /// `used_extension` — You already have a subaccount using this extension
    UsedExtension,
    /// `used_extension_in_location` — You already have a subaccount using extension in this location
    UsedExtensionInLocation,
    /// `used_filter` — You already have a record with this Filter
    UsedFilter,
    /// `used_ip` — There is already another customer using this IP Address
    UsedIP,
    /// `used_name` — You already have an entry using this name
    UsedName,
    /// `used_number` — You already have a record with this Number
    UsedNumber,
    /// `used_password` — This password has been used previously by this account.
    UsedPassword,
    /// `used_speed_dial` — You have an entry with this Speed Dial
    UsedSpeedDial,
    /// `used_username` — You already have a subaccount using this Username.
    UsedUsername,
    /// `weak_password` — This Password is too weak or too common
    WeakPassword,
    /// A `status` value not present in the documented table,
    /// preserved verbatim.
    Unknown(String),
}

impl ApiStatus {
    /// The verbatim wire `status` string.
    pub fn as_str(&self) -> &str {
        match self {
            ApiStatus::AccountWithDIDs => "account_with_dids",
            ApiStatus::APILimitExceeded => "api_limit_exceeded",
            ApiStatus::APINotEnabled => "api_not_enabled",
            ApiStatus::CancelFailed => "cancel_failed",
            ApiStatus::CANHaveOnlyOneProfileWithoutPIN => "can_have_only_one_profile_without_pin",
            ApiStatus::ConferenceMemberRelationNotFound => "conference_member_relation_not_found",
            ApiStatus::DIDInUse => "did_in_use",
            ApiStatus::DIDLimitReached => "did_limit_reached",
            ApiStatus::DuplicatedName => "duplicated_name",
            ApiStatus::DuplicatedPIN => "duplicated_pin",
            ApiStatus::E911Disabled => "e911_disabled",
            ApiStatus::E911Pending => "e911_pending",
            ApiStatus::ErrorDeletingMsg => "error_deleting_msg",
            ApiStatus::ErrorMovingMsg => "error_moving_msg",
            ApiStatus::ExceedsFileSize => "exceeds_file_size",
            ApiStatus::ExistingDID => "existing_did",
            ApiStatus::ForwardsExceeded => "forwards_exceeded",
            ApiStatus::InvalidAccount => "invalid_account",
            ApiStatus::InvalidAddress => "invalid_address",
            ApiStatus::InvalidAdmin => "invalid_admin",
            ApiStatus::InvalidAgentRingTimeout => "invalid_agent_ring_timeout",
            ApiStatus::InvalidAllowedcodecs => "invalid_allowedcodecs",
            ApiStatus::InvalidAnnounceJoinLeave => "invalid_announce_join_leave",
            ApiStatus::InvalidAnnounceOnlyUser => "invalid_announce_only_user",
            ApiStatus::InvalidAnnouncePositionFrequency => "invalid_announce_position_frequency",
            ApiStatus::InvalidAnnounceRoundSeconds => "invalid_announce_round_seconds",
            ApiStatus::InvalidAnnounceUserCount => "invalid_announce_user_count",
            ApiStatus::InvalidAreaCode => "invalid_area_code",
            ApiStatus::InvalidAttachid => "invalid_attachid",
            ApiStatus::InvalidAttachmessage => "invalid_attachmessage",
            ApiStatus::InvalidAttachFile => "invalid_attach_file",
            ApiStatus::InvalidAuthtype => "invalid_authtype",
            ApiStatus::InvalidAuthtypeH323 => "invalid_authtype_h323",
            ApiStatus::InvalidAuthtypeIax2 => "invalid_authtype_iax2",
            ApiStatus::InvalidBalancemanagement => "invalid_balancemanagement",
            ApiStatus::InvalidBaseRecording => "invalid_base_recording",
            ApiStatus::InvalidBillingtype => "invalid_billingtype",
            ApiStatus::InvalidCallback => "invalid_callback",
            ApiStatus::InvalidCallbackEnable => "invalid_callback_enable",
            ApiStatus::InvalidCallbackRetry => "invalid_callback_retry",
            ApiStatus::InvalidCallerid => "invalid_callerid",
            ApiStatus::InvalidCalleridprefix => "invalid_calleridprefix",
            ApiStatus::InvalidCalleridOverride => "invalid_callerid_override",
            ApiStatus::InvalidCallhunting => "invalid_callhunting",
            ApiStatus::InvalidCallparking => "invalid_callparking",
            ApiStatus::InvalidCallrecording => "invalid_callrecording",
            ApiStatus::InvalidCallType => "invalid_call_type",
            ApiStatus::InvalidCanadaRouting => "invalid_canada_routing",
            ApiStatus::InvalidCarrier => "invalid_carrier",
            ApiStatus::InvalidCharge => "invalid_charge",
            ApiStatus::InvalidCity => "invalid_city",
            ApiStatus::InvalidClient => "invalid_client",
            ApiStatus::InvalidCNAM => "invalid_cnam",
            ApiStatus::InvalidCodec => "invalid_codec",
            ApiStatus::InvalidConference => "invalid_conference",
            ApiStatus::InvalidContact => "invalid_contact",
            ApiStatus::InvalidCountry => "invalid_country",
            ApiStatus::InvalidCountryid => "invalid_countryid",
            ApiStatus::InvalidCredentials => "invalid_credentials",
            ApiStatus::InvalidDate => "invalid_date",
            ApiStatus::InvalidDaterange => "invalid_daterange",
            ApiStatus::InvalidDatetime => "invalid_datetime",
            ApiStatus::InvalidDateFrom => "invalid_date_from",
            ApiStatus::InvalidDayrange => "invalid_dayrange",
            ApiStatus::InvalidDelayBefore => "invalid_delay_before",
            ApiStatus::InvalidDeletemessage => "invalid_deletemessage",
            ApiStatus::InvalidDescription => "invalid_description",
            ApiStatus::InvalidDestination => "invalid_destination",
            ApiStatus::InvalidDestinationFolder => "invalid_destination_folder",
            ApiStatus::InvalidDevicetype => "invalid_devicetype",
            ApiStatus::InvalidDialtime => "invalid_dialtime",
            ApiStatus::InvalidDID => "invalid_did",
            ApiStatus::InvalidDigits => "invalid_digits",
            ApiStatus::InvalidDigitTimeout => "invalid_digit_timeout",
            ApiStatus::InvalidDISA => "invalid_disa",
            ApiStatus::InvalidDiversionHeader => "invalid_diversion_header",
            ApiStatus::InvalidDropSilence => "invalid_drop_silence",
            ApiStatus::InvalidDST => "invalid_dst",
            ApiStatus::InvalidDtmfmode => "invalid_dtmfmode",
            ApiStatus::InvalidDTMFDigits => "invalid_dtmf_digits",
            ApiStatus::InvalidEmail => "invalid_email",
            ApiStatus::InvalidEmailAttachmentFormat => "invalid_email_attachment_format",
            ApiStatus::InvalidEmailEnable => "invalid_email_enable",
            ApiStatus::InvalidEnableIPRestriction => "invalid_enable_ip_restriction",
            ApiStatus::InvalidEnablePOPRestriction => "invalid_enable_pop_restriction",
            ApiStatus::InvalidEndhour => "invalid_endhour",
            ApiStatus::InvalidEndminute => "invalid_endminute",
            ApiStatus::InvalidExtension => "invalid_extension",
            ApiStatus::InvalidExtensions => "invalid_extensions",
            ApiStatus::InvalidExtensionLength => "invalid_extension_length",
            ApiStatus::InvalidExtensionPrefix => "invalid_extension_prefix",
            ApiStatus::InvalidFailoverHeader => "invalid_failover_header",
            ApiStatus::InvalidFAXID => "invalid_fax_id",
            ApiStatus::InvalidFile => "invalid_file",
            ApiStatus::InvalidFilter => "invalid_filter",
            ApiStatus::InvalidFirstname => "invalid_firstname",
            ApiStatus::InvalidFocEnddate => "invalid_foc_enddate",
            ApiStatus::InvalidFocStartdate => "invalid_foc_startdate",
            ApiStatus::InvalidFolder => "invalid_folder",
            ApiStatus::InvalidFolderID => "invalid_folder_id",
            ApiStatus::InvalidForwarding => "invalid_forwarding",
            ApiStatus::InvalidForwardingDID => "invalid_forwarding_did",
            ApiStatus::InvalidForwardEnable => "invalid_forward_enable",
            ApiStatus::InvalidFrequencyAnnouncement => "invalid_frequency_announcement",
            ApiStatus::InvalidFromNumber => "invalid_from_number",
            ApiStatus::InvalidFullname => "invalid_fullname",
            ApiStatus::InvalidID => "invalid_id",
            ApiStatus::InvalidIfAnnouncePositionEnabledReportE => {
                "invalid_if_announce_position_enabled_report_e"
            }
            ApiStatus::InvalidInternaldialtime => "invalid_internaldialtime",
            ApiStatus::InvalidInternalvoicemail => "invalid_internalvoicemail",
            ApiStatus::InvalidInternationalroute => "invalid_internationalroute",
            ApiStatus::InvalidInvoiceType => "invalid_invoice_type",
            ApiStatus::InvalidIP => "invalid_ip",
            ApiStatus::InvalidIPAuth => "invalid_ip_auth",
            ApiStatus::InvalidIPIax2 => "invalid_ip_iax2",
            ApiStatus::InvalidIVR => "invalid_ivr",
            ApiStatus::InvalidJitterBuffer => "invalid_jitter_buffer",
            ApiStatus::InvalidJoinAnnouncement => "invalid_join_announcement",
            ApiStatus::InvalidJoinEmptyType => "invalid_join_empty_type",
            ApiStatus::InvalidLanguage => "invalid_language",
            ApiStatus::InvalidLastname => "invalid_lastname",
            ApiStatus::InvalidListened => "invalid_listened",
            ApiStatus::InvalidLocation => "invalid_location",
            ApiStatus::InvalidLockinternational => "invalid_lockinternational",
            ApiStatus::InvalidMailbox => "invalid_mailbox",
            ApiStatus::InvalidMaximumCallers => "invalid_maximum_callers",
            ApiStatus::InvalidMaximumWaitTime => "invalid_maximum_wait_time",
            ApiStatus::InvalidMaxExpiry => "invalid_max_expiry",
            ApiStatus::InvalidMember => "invalid_member",
            ApiStatus::InvalidMemberDelay => "invalid_member_delay",
            ApiStatus::InvalidMessageNum => "invalid_message_num",
            ApiStatus::InvalidMethod => "invalid_method",
            ApiStatus::InvalidMinute => "invalid_minute",
            ApiStatus::InvalidMixedNumbers => "invalid_mixed_numbers",
            ApiStatus::InvalidMonthly => "invalid_monthly",
            ApiStatus::InvalidMusiconhold => "invalid_musiconhold",
            ApiStatus::InvalidName => "invalid_name",
            ApiStatus::InvalidNAT => "invalid_nat",
            ApiStatus::InvalidNote => "invalid_note",
            ApiStatus::InvalidNumber => "invalid_number",
            ApiStatus::InvalidNumbermembers => "invalid_numbermembers",
            ApiStatus::InvalidNumberCanadian => "invalid_number_canadian",
            ApiStatus::InvalidNumberExist => "invalid_number_exist",
            ApiStatus::InvalidNumberFAX => "invalid_number_fax",
            ApiStatus::InvalidNumberPorttype => "invalid_number_porttype",
            ApiStatus::InvalidNumberUS => "invalid_number_us",
            ApiStatus::InvalidOrder => "invalid_order",
            ApiStatus::InvalidPackage => "invalid_package",
            ApiStatus::InvalidPassword => "invalid_password",
            ApiStatus::InvalidPasswordAuth => "invalid_password_auth",
            ApiStatus::InvalidPasswordIlegalCharacters => "invalid_password_ilegal_characters",
            ApiStatus::InvalidPasswordLessthan8charactersLong => {
                "invalid_password_lessthan_8characters_long"
            }
            ApiStatus::InvalidPasswordMissingLowercase => "invalid_password_missing_lowercase",
            ApiStatus::InvalidPasswordMissingNumber => "invalid_password_missing_number",
            ApiStatus::InvalidPasswordMissingUppercase => "invalid_password_missing_uppercase",
            ApiStatus::InvalidPause => "invalid_pause",
            ApiStatus::InvalidPayment => "invalid_payment",
            ApiStatus::InvalidPhonebook => "invalid_phonebook",
            ApiStatus::InvalidPhonenumber => "invalid_phonenumber",
            ApiStatus::InvalidPIN => "invalid_pin",
            ApiStatus::InvalidPINNumber => "invalid_pin_number",
            ApiStatus::InvalidPlayinstructions => "invalid_playinstructions",
            ApiStatus::InvalidPOPRestriction => "invalid_pop_restriction",
            ApiStatus::InvalidPortingid => "invalid_portingid",
            ApiStatus::InvalidPorttype => "invalid_porttype",
            ApiStatus::InvalidPortStatus => "invalid_port_status",
            ApiStatus::InvalidPriority => "invalid_priority",
            ApiStatus::InvalidPriorityWeight => "invalid_priority_weight",
            ApiStatus::InvalidProtocol => "invalid_protocol",
            ApiStatus::InvalidProviderAccount => "invalid_provider_account",
            ApiStatus::InvalidProviderName => "invalid_provider_name",
            ApiStatus::InvalidProvince => "invalid_province",
            ApiStatus::InvalidQuantity => "invalid_quantity",
            ApiStatus::InvalidQuery => "invalid_query",
            ApiStatus::InvalidQueue => "invalid_queue",
            ApiStatus::InvalidQuiet => "invalid_quiet",
            ApiStatus::InvalidRecording => "invalid_recording",
            ApiStatus::InvalidRecordingSoundErrorMenu => "invalid_recording_sound_error_menu",
            ApiStatus::InvalidRecordingSoundGetPIN => "invalid_recording_sound_get_pin",
            ApiStatus::InvalidRecordingSoundHasJoined => "invalid_recording_sound_has_joined",
            ApiStatus::InvalidRecordingSoundHasLeft => "invalid_recording_sound_has_left",
            ApiStatus::InvalidRecordingSoundInvalidPIN => "invalid_recording_sound_invalid_pin",
            ApiStatus::InvalidRecordingSoundJoin => "invalid_recording_sound_join",
            ApiStatus::InvalidRecordingSoundKicked => "invalid_recording_sound_kicked",
            ApiStatus::InvalidRecordingSoundLeave => "invalid_recording_sound_leave",
            ApiStatus::InvalidRecordingSoundLocked => "invalid_recording_sound_locked",
            ApiStatus::InvalidRecordingSoundLockedNow => "invalid_recording_sound_locked_now",
            ApiStatus::InvalidRecordingSoundMuted => "invalid_recording_sound_muted",
            ApiStatus::InvalidRecordingSoundOnlyOne => "invalid_recording_sound_only_one",
            ApiStatus::InvalidRecordingSoundOnlyPerson => "invalid_recording_sound_only_person",
            ApiStatus::InvalidRecordingSoundOtherInParty => {
                "invalid_recording_sound_other_in_party"
            }
            ApiStatus::InvalidRecordingSoundParticipantsMuted => {
                "invalid_recording_sound_participants_muted"
            }
            ApiStatus::InvalidRecordingSoundParticipantsUnmuted => {
                "invalid_recording_sound_participants_unmuted"
            }
            ApiStatus::InvalidRecordingSoundPlaceIntoConference => {
                "invalid_recording_sound_place_into_conference"
            }
            ApiStatus::InvalidRecordingSoundThereAre => "invalid_recording_sound_there_are",
            ApiStatus::InvalidRecordingSoundUnlockedNow => "invalid_recording_sound_unlocked_now",
            ApiStatus::InvalidRecordingSoundUnmuted => "invalid_recording_sound_unmuted",
            ApiStatus::InvalidRecordCalls => "invalid_record_calls",
            ApiStatus::InvalidReportHoldTimeAgent => "invalid_report_hold_time_agent",
            ApiStatus::InvalidResellerclient => "invalid_resellerclient",
            ApiStatus::InvalidResellernextbilling => "invalid_resellernextbilling",
            ApiStatus::InvalidResellerpackage => "invalid_resellerpackage",
            ApiStatus::InvalidResponseTimeout => "invalid_response_timeout",
            ApiStatus::InvalidRetryTimer => "invalid_retry_timer",
            ApiStatus::InvalidRinggroup => "invalid_ringgroup",
            ApiStatus::InvalidRingInuse => "invalid_ring_inuse",
            ApiStatus::InvalidRoute => "invalid_route",
            ApiStatus::InvalidRoutingHeader => "invalid_routing_header",
            ApiStatus::InvalidRTPHoldTimeout => "invalid_rtp_hold_timeout",
            ApiStatus::InvalidRTPTimeout => "invalid_rtp_timeout",
            ApiStatus::InvalidSaycallerid => "invalid_saycallerid",
            ApiStatus::InvalidSaytime => "invalid_saytime",
            ApiStatus::InvalidSecurityCode => "invalid_security_code",
            ApiStatus::InvalidServerpop => "invalid_serverpop",
            ApiStatus::InvalidSetup => "invalid_setup",
            ApiStatus::InvalidSilenceThreshold => "invalid_silence_threshold",
            ApiStatus::InvalidSIPURI => "invalid_sipuri",
            ApiStatus::InvalidSIPTraffic => "invalid_sip_traffic",
            ApiStatus::InvalidSkippassword => "invalid_skippassword",
            ApiStatus::InvalidSmppPassword => "invalid_smpp_password",
            ApiStatus::InvalidSmppURL => "invalid_smpp_url",
            ApiStatus::InvalidSmppUsername => "invalid_smpp_username",
            ApiStatus::InvalidSMS => "invalid_sms",
            ApiStatus::InvalidSMSForward => "invalid_sms_forward",
            ApiStatus::InvalidSnn => "invalid_snn",
            ApiStatus::InvalidSpeedDial => "invalid_speed_dial",
            ApiStatus::InvalidStarthour => "invalid_starthour",
            ApiStatus::InvalidStartminute => "invalid_startminute",
            ApiStatus::InvalidStartMuted => "invalid_start_muted",
            ApiStatus::InvalidState => "invalid_state",
            ApiStatus::InvalidStatementName => "invalid_statement_name",
            ApiStatus::InvalidStrategy => "invalid_strategy",
            ApiStatus::InvalidStreetName => "invalid_street_name",
            ApiStatus::InvalidStreetNumber => "invalid_street_number",
            ApiStatus::InvalidTalkingThreshold => "invalid_talking_threshold",
            ApiStatus::InvalidTalkDetection => "invalid_talk_detection",
            ApiStatus::InvalidTfnumberPorttype => "invalid_tfnumber_porttype",
            ApiStatus::InvalidThankyouForYourPatience => "invalid_thankyou_for_your_patience",
            ApiStatus::InvalidThreshold => "Invalid_threshold",
            ApiStatus::InvalidTimecondition => "invalid_timecondition",
            ApiStatus::InvalidTimeout => "invalid_timeout",
            ApiStatus::InvalidTimerange => "invalid_timerange",
            ApiStatus::InvalidTimezone => "invalid_timezone",
            ApiStatus::InvalidToNumber => "invalid_to_number",
            ApiStatus::InvalidTranscriptionEmail => "invalid_transcription_email",
            ApiStatus::InvalidTranscriptionFormat => "invalid_transcription_format",
            ApiStatus::InvalidTranscriptionLocale => "invalid_transcription_locale",
            ApiStatus::InvalidTranscriptionRedaction => "invalid_transcription_redaction",
            ApiStatus::InvalidTranscriptionSentiment => "invalid_transcription_sentiment",
            ApiStatus::InvalidTranscriptionSummary => "invalid_transcription_summary",
            ApiStatus::InvalidType => "invalid_type",
            ApiStatus::InvalidUrgent => "invalid_urgent",
            ApiStatus::InvalidUsername => "invalid_username",
            ApiStatus::InvalidVoicemailsetup => "invalid_voicemailsetup",
            ApiStatus::InvalidVoiceAnnouncement => "invalid_voice_announcement",
            ApiStatus::InvalidWeekdayend => "invalid_weekdayend",
            ApiStatus::InvalidWeekdaystart => "invalid_weekdaystart",
            ApiStatus::InvalidWrapupTime => "invalid_wrapup_time",
            ApiStatus::InvalidZip => "invalid_zip",
            ApiStatus::IPNotEnabled => "ip_not_enabled",
            ApiStatus::LimitReached => "limit_reached",
            ApiStatus::LocationAlreadyExists => "location_already_exists",
            ApiStatus::LocationLinkedToSubaccount => "location_linked_to_subaccount",
            ApiStatus::LocationNotFound => "location_not_found",
            ApiStatus::MaxPhonebook => "max_phonebook",
            ApiStatus::MembersExceeded => "members_exceeded",
            ApiStatus::MemberAlreadyIncluded => "member_already_included",
            ApiStatus::MessageEmpty => "message_empty",
            ApiStatus::MessageNotFound => "message_not_found",
            ApiStatus::MethodMaintenance => "method_maintenance",
            ApiStatus::MismatchEmailConfirm => "mismatch_email_confirm",
            ApiStatus::MismatchPasswordConfirm => "mismatch_password_confirm",
            ApiStatus::MissingAccount => "missing_account",
            ApiStatus::MissingAddress => "missing_address",
            ApiStatus::MissingAgentRingTimeout => "missing_agent_ring_timeout",
            ApiStatus::MissingAllowedcodecs => "missing_allowedcodecs",
            ApiStatus::MissingAttachmessage => "missing_attachmessage",
            ApiStatus::MissingAuthtype => "missing_authtype",
            ApiStatus::MissingBalancemanagement => "missing_balancemanagement",
            ApiStatus::MissingBillingtype => "missing_billingtype",
            ApiStatus::MissingCallback => "missing_callback",
            ApiStatus::MissingCallerid => "missing_callerid",
            ApiStatus::MissingCallhunting => "missing_callhunting",
            ApiStatus::MissingCallparking => "missing_callparking",
            ApiStatus::MissingCallrecording => "missing_callrecording",
            ApiStatus::MissingCarrier => "missing_carrier",
            ApiStatus::MissingCharge => "missing_charge",
            ApiStatus::MissingChoices => "missing_choices",
            ApiStatus::MissingCity => "missing_city",
            ApiStatus::MissingClient => "missing_client",
            ApiStatus::MissingCNAM => "missing_cnam",
            ApiStatus::MissingCodec => "missing_codec",
            ApiStatus::MissingConference => "missing_conference",
            ApiStatus::MissingCountry => "missing_country",
            ApiStatus::MissingCountryid => "missing_countryid",
            ApiStatus::MissingCredentials => "missing_credentials",
            ApiStatus::MissingDatetime => "missing_datetime",
            ApiStatus::MissingDelayBefore => "missing_delay_before",
            ApiStatus::MissingDeletemessage => "missing_deletemessage",
            ApiStatus::MissingDescription => "missing_description",
            ApiStatus::MissingDevicetype => "missing_devicetype",
            ApiStatus::MissingDialtime => "missing_dialtime",
            ApiStatus::MissingDID => "missing_did",
            ApiStatus::MissingDigits => "missing_digits",
            ApiStatus::MissingDigitTimeout => "missing_digit_timeout",
            ApiStatus::MissingDISA => "missing_disa",
            ApiStatus::MissingDtmfmode => "missing_dtmfmode",
            ApiStatus::MissingEmail => "missing_email",
            ApiStatus::MissingEmailConfirm => "missing_email_confirm",
            ApiStatus::MissingEnable => "missing_enable",
            ApiStatus::MissingEndhour => "missing_endhour",
            ApiStatus::MissingEndminute => "missing_endminute",
            ApiStatus::MissingFailoverBusy => "missing_failover_busy",
            ApiStatus::MissingFailoverNoanswer => "missing_failover_noanswer",
            ApiStatus::MissingFailoverUnreachable => "missing_failover_unreachable",
            ApiStatus::MissingFile => "missing_file",
            ApiStatus::MissingFilter => "missing_filter",
            ApiStatus::MissingFirstname => "missing_firstname",
            ApiStatus::MissingFolder => "missing_folder",
            ApiStatus::MissingForwarding => "missing_forwarding",
            ApiStatus::MissingFromDate => "missing_from_date",
            ApiStatus::MissingFullname => "missing_fullname",
            ApiStatus::MissingID => "missing_id",
            ApiStatus::MissingIfAnnouncePositionEnabledReportE => {
                "missing_if_announce_position_enabled_report_e"
            }
            ApiStatus::MissingInternationalroute => "missing_internationalroute",
            ApiStatus::MissingIP => "missing_ip",
            ApiStatus::MissingIPH323 => "missing_ip_h323",
            ApiStatus::MissingIPRestriction => "missing_ip_restriction",
            ApiStatus::MissingIVR => "missing_ivr",
            ApiStatus::MissingJoinWhenEmpty => "missing_join_when_empty",
            ApiStatus::MissingLanguage => "missing_language",
            ApiStatus::MissingLastname => "missing_lastname",
            ApiStatus::MissingLeaveWhenEmpty => "missing_leave_when_empty",
            ApiStatus::MissingLength => "missing_length",
            ApiStatus::MissingListened => "missing_listened",
            ApiStatus::MissingLocation => "missing_location",
            ApiStatus::MissingLocationName => "missing_location_name",
            ApiStatus::MissingLockinternational => "missing_lockinternational",
            ApiStatus::MissingMailbox => "missing_mailbox",
            ApiStatus::MissingMember => "missing_member",
            ApiStatus::MissingMembers => "missing_members",
            ApiStatus::MissingMessageNum => "missing_message_num",
            ApiStatus::MissingMethod => "missing_method",
            ApiStatus::MissingMinute => "missing_minute",
            ApiStatus::MissingMonthly => "missing_monthly",
            ApiStatus::MissingMusiconhold => "missing_musiconhold",
            ApiStatus::MissingName => "missing_name",
            ApiStatus::MissingNAT => "missing_nat",
            ApiStatus::MissingNumber => "missing_number",
            ApiStatus::MissingNumbers => "missing_numbers",
            ApiStatus::MissingPackage => "missing_package",
            ApiStatus::MissingParams => "missing_params",
            ApiStatus::MissingPassword => "missing_password",
            ApiStatus::MissingPasswordConfirm => "missing_password_confirm",
            ApiStatus::MissingPayment => "missing_payment",
            ApiStatus::MissingPhonebook => "missing_phonebook",
            ApiStatus::MissingPhonenumber => "missing_phonenumber",
            ApiStatus::MissingPIN => "missing_pin",
            ApiStatus::MissingPlayinstructions => "missing_playinstructions",
            ApiStatus::MissingPOPRestriction => "missing_pop_restriction",
            ApiStatus::MissingPriority => "missing_priority",
            ApiStatus::MissingPriorityWeight => "missing_priority_weight",
            ApiStatus::MissingProtocol => "missing_protocol",
            ApiStatus::MissingProvince => "missing_province",
            ApiStatus::MissingQuery => "missing_query",
            ApiStatus::MissingRecording => "missing_recording",
            ApiStatus::MissingReportHoldTimeAgent => "missing_report_hold_time_agent",
            ApiStatus::MissingResellerclient => "missing_resellerclient",
            ApiStatus::MissingResellerpackage => "missing_resellerpackage",
            ApiStatus::MissingResponseTimeout => "missing_response_timeout",
            ApiStatus::MissingRinggroup => "missing_ringgroup",
            ApiStatus::MissingRingInuse => "missing_ring_inuse",
            ApiStatus::MissingRingStrategy => "missing_ring_strategy",
            ApiStatus::MissingRoute => "missing_route",
            ApiStatus::MissingRouting => "missing_routing",
            ApiStatus::MissingSaycallerid => "missing_saycallerid",
            ApiStatus::MissingSaytime => "missing_saytime",
            ApiStatus::MissingServerpop => "missing_serverpop",
            ApiStatus::MissingSetup => "missing_setup",
            ApiStatus::MissingSIPURI => "missing_sipuri",
            ApiStatus::MissingSkippassword => "missing_skippassword",
            ApiStatus::MissingSMS => "missing_sms",
            ApiStatus::MissingSpeedDial => "missing_speed_dial",
            ApiStatus::MissingStart => "missing_start",
            ApiStatus::MissingStarthour => "missing_starthour",
            ApiStatus::MissingStartminute => "missing_startminute",
            ApiStatus::MissingState => "missing_state",
            ApiStatus::MissingStreetName => "missing_street_name",
            ApiStatus::MissingStreetNumber => "missing_street_number",
            ApiStatus::MissingThankyouForYourPatience => "missing_thankyou_for_your_patience",
            ApiStatus::MissingTimecondition => "missing_timecondition",
            ApiStatus::MissingTimeout => "missing_timeout",
            ApiStatus::MissingTimezone => "missing_timezone",
            ApiStatus::MissingToDate => "missing_to_date",
            ApiStatus::MissingTranscriptionEmail => "missing_transcription_email",
            ApiStatus::MissingTranscriptionLocale => "missing_transcription_locale",
            ApiStatus::MissingType => "missing_type",
            ApiStatus::MissingUrgent => "missing_urgent",
            ApiStatus::MissingURI => "missing_uri",
            ApiStatus::MissingUsername => "missing_username",
            ApiStatus::MissingVoicemailsetup => "missing_voicemailsetup",
            ApiStatus::MissingWeekdayend => "missing_weekdayend",
            ApiStatus::MissingWeekdaystart => "missing_weekdaystart",
            ApiStatus::MissingZip => "missing_zip",
            ApiStatus::MovingFail => "moving_fail",
            ApiStatus::NameToolong => "name_toolong",
            ApiStatus::NonSufficientFunds => "non_sufficient_funds",
            ApiStatus::NoteToolong => "note_toolong",
            ApiStatus::NoAccount => "no_account",
            ApiStatus::NoAttachments => "no_attachments",
            ApiStatus::NoBase64file => "no_base64file",
            ApiStatus::NoCallback => "no_callback",
            ApiStatus::NoCallhunting => "no_callhunting",
            ApiStatus::NoCallparking => "no_callparking",
            ApiStatus::NoCallstatus => "no_callstatus",
            ApiStatus::NoCDR => "no_cdr",
            ApiStatus::NoChangeBillingtype => "no_change_billingtype",
            ApiStatus::NoClient => "no_client",
            ApiStatus::NoConference => "no_conference",
            ApiStatus::NoDID => "no_did",
            ApiStatus::NoDISA => "no_disa",
            ApiStatus::NoEmailtofax => "no_emailtofax",
            ApiStatus::NoFilter => "no_filter",
            ApiStatus::NoFolder => "no_folder",
            ApiStatus::NoForwarding => "no_forwarding",
            ApiStatus::NoIVR => "no_ivr",
            ApiStatus::NoMailbox => "no_mailbox",
            ApiStatus::NoMember => "no_member",
            ApiStatus::NoMessage => "no_message",
            ApiStatus::NoMessages => "no_messages",
            ApiStatus::NoNumbers => "no_numbers",
            ApiStatus::NoPackage => "no_package",
            ApiStatus::NoPhonebook => "no_phonebook",
            ApiStatus::NoPhonebookGroup => "no_phonebook_group",
            ApiStatus::NoProvision => "no_provision",
            ApiStatus::NoProvisionUpdate => "no_provision_update",
            ApiStatus::NoQueue => "no_queue",
            ApiStatus::NoRate => "no_rate",
            ApiStatus::NoRecording => "no_recording",
            ApiStatus::NoRinggroup => "no_ringgroup",
            ApiStatus::NoSequences => "no_sequences",
            ApiStatus::NoSIPURI => "no_sipuri",
            ApiStatus::NoSMS => "no_sms",
            ApiStatus::NoTimecondition => "no_timecondition",
            ApiStatus::NoTransactions => "no_transactions",
            ApiStatus::NoVPRI => "no_vpri",
            ApiStatus::OrderFailed => "order_failed",
            ApiStatus::ProblemSendingMail => "problem_sending_mail",
            ApiStatus::ProviderOutofservice => "provider_outofservice",
            ApiStatus::RecordingInUseCallerIDFiltering => "recording_in_use_caller_id_filtering",
            ApiStatus::RecordingInUseCallerTimecondition => "recording_in_use_caller_timecondition",
            ApiStatus::RecordingInUseDID => "recording_in_use_did",
            ApiStatus::RecordingInUseIVR => "recording_in_use_ivr",
            ApiStatus::RecordingInUseQueue => "recording_in_use_queue",
            ApiStatus::RepeatedIP => "repeated_ip",
            ApiStatus::ReservedIP => "reserved_ip",
            ApiStatus::RTPTimeoutGreaterThanRTPHoldTimeout => {
                "rtp_timeout_greater_than_rtp_hold_timeout"
            }
            ApiStatus::SameDIDBillingtype => "same_did_billingtype",
            ApiStatus::SentFail => "sent_fail",
            ApiStatus::SIPURIInPhonebook => "sipuri_in_phonebook",
            ApiStatus::SMSApplyRegulations => "sms_apply_regulations",
            ApiStatus::SMSFailed => "sms_failed",
            ApiStatus::SMSToolong => "sms_toolong",
            ApiStatus::SMSWaitMessage => "sms_wait_message",
            ApiStatus::TlsError => "tls_error",
            ApiStatus::UnableToPurchase => "Unable_to_purchase",
            ApiStatus::UnavailableInfo => "unavailable_info",
            ApiStatus::UnsifficientStock => "unsifficient_stock",
            ApiStatus::UsedDescription => "used_description",
            ApiStatus::UsedEmail => "used_email",
            ApiStatus::UsedExtension => "used_extension",
            ApiStatus::UsedExtensionInLocation => "used_extension_in_location",
            ApiStatus::UsedFilter => "used_filter",
            ApiStatus::UsedIP => "used_ip",
            ApiStatus::UsedName => "used_name",
            ApiStatus::UsedNumber => "used_number",
            ApiStatus::UsedPassword => "used_password",
            ApiStatus::UsedSpeedDial => "used_speed_dial",
            ApiStatus::UsedUsername => "used_username",
            ApiStatus::WeakPassword => "weak_password",
            ApiStatus::Unknown(s) => s.as_str(),
        }
    }

    /// Parse a wire `status` string. Unknown values are preserved
    /// in [`ApiStatus::Unknown`].
    pub fn from_wire(s: &str) -> Self {
        match s {
            "account_with_dids" => ApiStatus::AccountWithDIDs,
            "api_limit_exceeded" => ApiStatus::APILimitExceeded,
            "api_not_enabled" => ApiStatus::APINotEnabled,
            "cancel_failed" => ApiStatus::CancelFailed,
            "can_have_only_one_profile_without_pin" => ApiStatus::CANHaveOnlyOneProfileWithoutPIN,
            "conference_member_relation_not_found" => ApiStatus::ConferenceMemberRelationNotFound,
            "did_in_use" => ApiStatus::DIDInUse,
            "did_limit_reached" => ApiStatus::DIDLimitReached,
            "duplicated_name" => ApiStatus::DuplicatedName,
            "duplicated_pin" => ApiStatus::DuplicatedPIN,
            "e911_disabled" => ApiStatus::E911Disabled,
            "e911_pending" => ApiStatus::E911Pending,
            "error_deleting_msg" => ApiStatus::ErrorDeletingMsg,
            "error_moving_msg" => ApiStatus::ErrorMovingMsg,
            "exceeds_file_size" => ApiStatus::ExceedsFileSize,
            "existing_did" => ApiStatus::ExistingDID,
            "forwards_exceeded" => ApiStatus::ForwardsExceeded,
            "invalid_account" => ApiStatus::InvalidAccount,
            "invalid_address" => ApiStatus::InvalidAddress,
            "invalid_admin" => ApiStatus::InvalidAdmin,
            "invalid_agent_ring_timeout" => ApiStatus::InvalidAgentRingTimeout,
            "invalid_allowedcodecs" => ApiStatus::InvalidAllowedcodecs,
            "invalid_announce_join_leave" => ApiStatus::InvalidAnnounceJoinLeave,
            "invalid_announce_only_user" => ApiStatus::InvalidAnnounceOnlyUser,
            "invalid_announce_position_frequency" => ApiStatus::InvalidAnnouncePositionFrequency,
            "invalid_announce_round_seconds" => ApiStatus::InvalidAnnounceRoundSeconds,
            "invalid_announce_user_count" => ApiStatus::InvalidAnnounceUserCount,
            "invalid_area_code" => ApiStatus::InvalidAreaCode,
            "invalid_attachid" => ApiStatus::InvalidAttachid,
            "invalid_attachmessage" => ApiStatus::InvalidAttachmessage,
            "invalid_attach_file" => ApiStatus::InvalidAttachFile,
            "invalid_authtype" => ApiStatus::InvalidAuthtype,
            "invalid_authtype_h323" => ApiStatus::InvalidAuthtypeH323,
            "invalid_authtype_iax2" => ApiStatus::InvalidAuthtypeIax2,
            "invalid_balancemanagement" => ApiStatus::InvalidBalancemanagement,
            "invalid_base_recording" => ApiStatus::InvalidBaseRecording,
            "invalid_billingtype" => ApiStatus::InvalidBillingtype,
            "invalid_callback" => ApiStatus::InvalidCallback,
            "invalid_callback_enable" => ApiStatus::InvalidCallbackEnable,
            "invalid_callback_retry" => ApiStatus::InvalidCallbackRetry,
            "invalid_callerid" => ApiStatus::InvalidCallerid,
            "invalid_calleridprefix" => ApiStatus::InvalidCalleridprefix,
            "invalid_callerid_override" => ApiStatus::InvalidCalleridOverride,
            "invalid_callhunting" => ApiStatus::InvalidCallhunting,
            "invalid_callparking" => ApiStatus::InvalidCallparking,
            "invalid_callrecording" => ApiStatus::InvalidCallrecording,
            "invalid_call_type" => ApiStatus::InvalidCallType,
            "invalid_canada_routing" => ApiStatus::InvalidCanadaRouting,
            "invalid_carrier" => ApiStatus::InvalidCarrier,
            "invalid_charge" => ApiStatus::InvalidCharge,
            "invalid_city" => ApiStatus::InvalidCity,
            "invalid_client" => ApiStatus::InvalidClient,
            "invalid_cnam" => ApiStatus::InvalidCNAM,
            "invalid_codec" => ApiStatus::InvalidCodec,
            "invalid_conference" => ApiStatus::InvalidConference,
            "invalid_contact" => ApiStatus::InvalidContact,
            "invalid_country" => ApiStatus::InvalidCountry,
            "invalid_countryid" => ApiStatus::InvalidCountryid,
            "invalid_credentials" => ApiStatus::InvalidCredentials,
            "invalid_date" => ApiStatus::InvalidDate,
            "invalid_daterange" => ApiStatus::InvalidDaterange,
            "invalid_datetime" => ApiStatus::InvalidDatetime,
            "invalid_date_from" => ApiStatus::InvalidDateFrom,
            "invalid_dayrange" => ApiStatus::InvalidDayrange,
            "invalid_delay_before" => ApiStatus::InvalidDelayBefore,
            "invalid_deletemessage" => ApiStatus::InvalidDeletemessage,
            "invalid_description" => ApiStatus::InvalidDescription,
            "invalid_destination" => ApiStatus::InvalidDestination,
            "invalid_destination_folder" => ApiStatus::InvalidDestinationFolder,
            "invalid_devicetype" => ApiStatus::InvalidDevicetype,
            "invalid_dialtime" => ApiStatus::InvalidDialtime,
            "invalid_did" => ApiStatus::InvalidDID,
            "invalid_digits" => ApiStatus::InvalidDigits,
            "invalid_digit_timeout" => ApiStatus::InvalidDigitTimeout,
            "invalid_disa" => ApiStatus::InvalidDISA,
            "invalid_diversion_header" => ApiStatus::InvalidDiversionHeader,
            "invalid_drop_silence" => ApiStatus::InvalidDropSilence,
            "invalid_dst" => ApiStatus::InvalidDST,
            "invalid_dtmfmode" => ApiStatus::InvalidDtmfmode,
            "invalid_dtmf_digits" => ApiStatus::InvalidDTMFDigits,
            "invalid_email" => ApiStatus::InvalidEmail,
            "invalid_email_attachment_format" => ApiStatus::InvalidEmailAttachmentFormat,
            "invalid_email_enable" => ApiStatus::InvalidEmailEnable,
            "invalid_enable_ip_restriction" => ApiStatus::InvalidEnableIPRestriction,
            "invalid_enable_pop_restriction" => ApiStatus::InvalidEnablePOPRestriction,
            "invalid_endhour" => ApiStatus::InvalidEndhour,
            "invalid_endminute" => ApiStatus::InvalidEndminute,
            "invalid_extension" => ApiStatus::InvalidExtension,
            "invalid_extensions" => ApiStatus::InvalidExtensions,
            "invalid_extension_length" => ApiStatus::InvalidExtensionLength,
            "invalid_extension_prefix" => ApiStatus::InvalidExtensionPrefix,
            "invalid_failover_header" => ApiStatus::InvalidFailoverHeader,
            "invalid_fax_id" => ApiStatus::InvalidFAXID,
            "invalid_file" => ApiStatus::InvalidFile,
            "invalid_filter" => ApiStatus::InvalidFilter,
            "invalid_firstname" => ApiStatus::InvalidFirstname,
            "invalid_foc_enddate" => ApiStatus::InvalidFocEnddate,
            "invalid_foc_startdate" => ApiStatus::InvalidFocStartdate,
            "invalid_folder" => ApiStatus::InvalidFolder,
            "invalid_folder_id" => ApiStatus::InvalidFolderID,
            "invalid_forwarding" => ApiStatus::InvalidForwarding,
            "invalid_forwarding_did" => ApiStatus::InvalidForwardingDID,
            "invalid_forward_enable" => ApiStatus::InvalidForwardEnable,
            "invalid_frequency_announcement" => ApiStatus::InvalidFrequencyAnnouncement,
            "invalid_from_number" => ApiStatus::InvalidFromNumber,
            "invalid_fullname" => ApiStatus::InvalidFullname,
            "invalid_id" => ApiStatus::InvalidID,
            "invalid_if_announce_position_enabled_report_e" => {
                ApiStatus::InvalidIfAnnouncePositionEnabledReportE
            }
            "invalid_internaldialtime" => ApiStatus::InvalidInternaldialtime,
            "invalid_internalvoicemail" => ApiStatus::InvalidInternalvoicemail,
            "invalid_internationalroute" => ApiStatus::InvalidInternationalroute,
            "invalid_invoice_type" => ApiStatus::InvalidInvoiceType,
            "invalid_ip" => ApiStatus::InvalidIP,
            "invalid_ip_auth" => ApiStatus::InvalidIPAuth,
            "invalid_ip_iax2" => ApiStatus::InvalidIPIax2,
            "invalid_ivr" => ApiStatus::InvalidIVR,
            "invalid_jitter_buffer" => ApiStatus::InvalidJitterBuffer,
            "invalid_join_announcement" => ApiStatus::InvalidJoinAnnouncement,
            "invalid_join_empty_type" => ApiStatus::InvalidJoinEmptyType,
            "invalid_language" => ApiStatus::InvalidLanguage,
            "invalid_lastname" => ApiStatus::InvalidLastname,
            "invalid_listened" => ApiStatus::InvalidListened,
            "invalid_location" => ApiStatus::InvalidLocation,
            "invalid_lockinternational" => ApiStatus::InvalidLockinternational,
            "invalid_mailbox" => ApiStatus::InvalidMailbox,
            "invalid_maximum_callers" => ApiStatus::InvalidMaximumCallers,
            "invalid_maximum_wait_time" => ApiStatus::InvalidMaximumWaitTime,
            "invalid_max_expiry" => ApiStatus::InvalidMaxExpiry,
            "invalid_member" => ApiStatus::InvalidMember,
            "invalid_member_delay" => ApiStatus::InvalidMemberDelay,
            "invalid_message_num" => ApiStatus::InvalidMessageNum,
            "invalid_method" => ApiStatus::InvalidMethod,
            "invalid_minute" => ApiStatus::InvalidMinute,
            "invalid_mixed_numbers" => ApiStatus::InvalidMixedNumbers,
            "invalid_monthly" => ApiStatus::InvalidMonthly,
            "invalid_musiconhold" => ApiStatus::InvalidMusiconhold,
            "invalid_name" => ApiStatus::InvalidName,
            "invalid_nat" => ApiStatus::InvalidNAT,
            "invalid_note" => ApiStatus::InvalidNote,
            "invalid_number" => ApiStatus::InvalidNumber,
            "invalid_numbermembers" => ApiStatus::InvalidNumbermembers,
            "invalid_number_canadian" => ApiStatus::InvalidNumberCanadian,
            "invalid_number_exist" => ApiStatus::InvalidNumberExist,
            "invalid_number_fax" => ApiStatus::InvalidNumberFAX,
            "invalid_number_porttype" => ApiStatus::InvalidNumberPorttype,
            "invalid_number_us" => ApiStatus::InvalidNumberUS,
            "invalid_order" => ApiStatus::InvalidOrder,
            "invalid_package" => ApiStatus::InvalidPackage,
            "invalid_password" => ApiStatus::InvalidPassword,
            "invalid_password_auth" => ApiStatus::InvalidPasswordAuth,
            "invalid_password_ilegal_characters" => ApiStatus::InvalidPasswordIlegalCharacters,
            "invalid_password_lessthan_8characters_long" => {
                ApiStatus::InvalidPasswordLessthan8charactersLong
            }
            "invalid_password_missing_lowercase" => ApiStatus::InvalidPasswordMissingLowercase,
            "invalid_password_missing_number" => ApiStatus::InvalidPasswordMissingNumber,
            "invalid_password_missing_uppercase" => ApiStatus::InvalidPasswordMissingUppercase,
            "invalid_pause" => ApiStatus::InvalidPause,
            "invalid_payment" => ApiStatus::InvalidPayment,
            "invalid_phonebook" => ApiStatus::InvalidPhonebook,
            "invalid_phonenumber" => ApiStatus::InvalidPhonenumber,
            "invalid_pin" => ApiStatus::InvalidPIN,
            "invalid_pin_number" => ApiStatus::InvalidPINNumber,
            "invalid_playinstructions" => ApiStatus::InvalidPlayinstructions,
            "invalid_pop_restriction" => ApiStatus::InvalidPOPRestriction,
            "invalid_portingid" => ApiStatus::InvalidPortingid,
            "invalid_porttype" => ApiStatus::InvalidPorttype,
            "invalid_port_status" => ApiStatus::InvalidPortStatus,
            "invalid_priority" => ApiStatus::InvalidPriority,
            "invalid_priority_weight" => ApiStatus::InvalidPriorityWeight,
            "invalid_protocol" => ApiStatus::InvalidProtocol,
            "invalid_provider_account" => ApiStatus::InvalidProviderAccount,
            "invalid_provider_name" => ApiStatus::InvalidProviderName,
            "invalid_province" => ApiStatus::InvalidProvince,
            "invalid_quantity" => ApiStatus::InvalidQuantity,
            "invalid_query" => ApiStatus::InvalidQuery,
            "invalid_queue" => ApiStatus::InvalidQueue,
            "invalid_quiet" => ApiStatus::InvalidQuiet,
            "invalid_recording" => ApiStatus::InvalidRecording,
            "invalid_recording_sound_error_menu" => ApiStatus::InvalidRecordingSoundErrorMenu,
            "invalid_recording_sound_get_pin" => ApiStatus::InvalidRecordingSoundGetPIN,
            "invalid_recording_sound_has_joined" => ApiStatus::InvalidRecordingSoundHasJoined,
            "invalid_recording_sound_has_left" => ApiStatus::InvalidRecordingSoundHasLeft,
            "invalid_recording_sound_invalid_pin" => ApiStatus::InvalidRecordingSoundInvalidPIN,
            "invalid_recording_sound_join" => ApiStatus::InvalidRecordingSoundJoin,
            "invalid_recording_sound_kicked" => ApiStatus::InvalidRecordingSoundKicked,
            "invalid_recording_sound_leave" => ApiStatus::InvalidRecordingSoundLeave,
            "invalid_recording_sound_locked" => ApiStatus::InvalidRecordingSoundLocked,
            "invalid_recording_sound_locked_now" => ApiStatus::InvalidRecordingSoundLockedNow,
            "invalid_recording_sound_muted" => ApiStatus::InvalidRecordingSoundMuted,
            "invalid_recording_sound_only_one" => ApiStatus::InvalidRecordingSoundOnlyOne,
            "invalid_recording_sound_only_person" => ApiStatus::InvalidRecordingSoundOnlyPerson,
            "invalid_recording_sound_other_in_party" => {
                ApiStatus::InvalidRecordingSoundOtherInParty
            }
            "invalid_recording_sound_participants_muted" => {
                ApiStatus::InvalidRecordingSoundParticipantsMuted
            }
            "invalid_recording_sound_participants_unmuted" => {
                ApiStatus::InvalidRecordingSoundParticipantsUnmuted
            }
            "invalid_recording_sound_place_into_conference" => {
                ApiStatus::InvalidRecordingSoundPlaceIntoConference
            }
            "invalid_recording_sound_there_are" => ApiStatus::InvalidRecordingSoundThereAre,
            "invalid_recording_sound_unlocked_now" => ApiStatus::InvalidRecordingSoundUnlockedNow,
            "invalid_recording_sound_unmuted" => ApiStatus::InvalidRecordingSoundUnmuted,
            "invalid_record_calls" => ApiStatus::InvalidRecordCalls,
            "invalid_report_hold_time_agent" => ApiStatus::InvalidReportHoldTimeAgent,
            "invalid_resellerclient" => ApiStatus::InvalidResellerclient,
            "invalid_resellernextbilling" => ApiStatus::InvalidResellernextbilling,
            "invalid_resellerpackage" => ApiStatus::InvalidResellerpackage,
            "invalid_response_timeout" => ApiStatus::InvalidResponseTimeout,
            "invalid_retry_timer" => ApiStatus::InvalidRetryTimer,
            "invalid_ringgroup" => ApiStatus::InvalidRinggroup,
            "invalid_ring_inuse" => ApiStatus::InvalidRingInuse,
            "invalid_route" => ApiStatus::InvalidRoute,
            "invalid_routing_header" => ApiStatus::InvalidRoutingHeader,
            "invalid_rtp_hold_timeout" => ApiStatus::InvalidRTPHoldTimeout,
            "invalid_rtp_timeout" => ApiStatus::InvalidRTPTimeout,
            "invalid_saycallerid" => ApiStatus::InvalidSaycallerid,
            "invalid_saytime" => ApiStatus::InvalidSaytime,
            "invalid_security_code" => ApiStatus::InvalidSecurityCode,
            "invalid_serverpop" => ApiStatus::InvalidServerpop,
            "invalid_setup" => ApiStatus::InvalidSetup,
            "invalid_silence_threshold" => ApiStatus::InvalidSilenceThreshold,
            "invalid_sipuri" => ApiStatus::InvalidSIPURI,
            "invalid_sip_traffic" => ApiStatus::InvalidSIPTraffic,
            "invalid_skippassword" => ApiStatus::InvalidSkippassword,
            "invalid_smpp_password" => ApiStatus::InvalidSmppPassword,
            "invalid_smpp_url" => ApiStatus::InvalidSmppURL,
            "invalid_smpp_username" => ApiStatus::InvalidSmppUsername,
            "invalid_sms" => ApiStatus::InvalidSMS,
            "invalid_sms_forward" => ApiStatus::InvalidSMSForward,
            "invalid_snn" => ApiStatus::InvalidSnn,
            "invalid_speed_dial" => ApiStatus::InvalidSpeedDial,
            "invalid_starthour" => ApiStatus::InvalidStarthour,
            "invalid_startminute" => ApiStatus::InvalidStartminute,
            "invalid_start_muted" => ApiStatus::InvalidStartMuted,
            "invalid_state" => ApiStatus::InvalidState,
            "invalid_statement_name" => ApiStatus::InvalidStatementName,
            "invalid_strategy" => ApiStatus::InvalidStrategy,
            "invalid_street_name" => ApiStatus::InvalidStreetName,
            "invalid_street_number" => ApiStatus::InvalidStreetNumber,
            "invalid_talking_threshold" => ApiStatus::InvalidTalkingThreshold,
            "invalid_talk_detection" => ApiStatus::InvalidTalkDetection,
            "invalid_tfnumber_porttype" => ApiStatus::InvalidTfnumberPorttype,
            "invalid_thankyou_for_your_patience" => ApiStatus::InvalidThankyouForYourPatience,
            "Invalid_threshold" => ApiStatus::InvalidThreshold,
            "invalid_timecondition" => ApiStatus::InvalidTimecondition,
            "invalid_timeout" => ApiStatus::InvalidTimeout,
            "invalid_timerange" => ApiStatus::InvalidTimerange,
            "invalid_timezone" => ApiStatus::InvalidTimezone,
            "invalid_to_number" => ApiStatus::InvalidToNumber,
            "invalid_transcription_email" => ApiStatus::InvalidTranscriptionEmail,
            "invalid_transcription_format" => ApiStatus::InvalidTranscriptionFormat,
            "invalid_transcription_locale" => ApiStatus::InvalidTranscriptionLocale,
            "invalid_transcription_redaction" => ApiStatus::InvalidTranscriptionRedaction,
            "invalid_transcription_sentiment" => ApiStatus::InvalidTranscriptionSentiment,
            "invalid_transcription_summary" => ApiStatus::InvalidTranscriptionSummary,
            "invalid_type" => ApiStatus::InvalidType,
            "invalid_urgent" => ApiStatus::InvalidUrgent,
            "invalid_username" => ApiStatus::InvalidUsername,
            "invalid_voicemailsetup" => ApiStatus::InvalidVoicemailsetup,
            "invalid_voice_announcement" => ApiStatus::InvalidVoiceAnnouncement,
            "invalid_weekdayend" => ApiStatus::InvalidWeekdayend,
            "invalid_weekdaystart" => ApiStatus::InvalidWeekdaystart,
            "invalid_wrapup_time" => ApiStatus::InvalidWrapupTime,
            "invalid_zip" => ApiStatus::InvalidZip,
            "ip_not_enabled" => ApiStatus::IPNotEnabled,
            "limit_reached" => ApiStatus::LimitReached,
            "location_already_exists" => ApiStatus::LocationAlreadyExists,
            "location_linked_to_subaccount" => ApiStatus::LocationLinkedToSubaccount,
            "location_not_found" => ApiStatus::LocationNotFound,
            "max_phonebook" => ApiStatus::MaxPhonebook,
            "members_exceeded" => ApiStatus::MembersExceeded,
            "member_already_included" => ApiStatus::MemberAlreadyIncluded,
            "message_empty" => ApiStatus::MessageEmpty,
            "message_not_found" => ApiStatus::MessageNotFound,
            "method_maintenance" => ApiStatus::MethodMaintenance,
            "mismatch_email_confirm" => ApiStatus::MismatchEmailConfirm,
            "mismatch_password_confirm" => ApiStatus::MismatchPasswordConfirm,
            "missing_account" => ApiStatus::MissingAccount,
            "missing_address" => ApiStatus::MissingAddress,
            "missing_agent_ring_timeout" => ApiStatus::MissingAgentRingTimeout,
            "missing_allowedcodecs" => ApiStatus::MissingAllowedcodecs,
            "missing_attachmessage" => ApiStatus::MissingAttachmessage,
            "missing_authtype" => ApiStatus::MissingAuthtype,
            "missing_balancemanagement" => ApiStatus::MissingBalancemanagement,
            "missing_billingtype" => ApiStatus::MissingBillingtype,
            "missing_callback" => ApiStatus::MissingCallback,
            "missing_callerid" => ApiStatus::MissingCallerid,
            "missing_callhunting" => ApiStatus::MissingCallhunting,
            "missing_callparking" => ApiStatus::MissingCallparking,
            "missing_callrecording" => ApiStatus::MissingCallrecording,
            "missing_carrier" => ApiStatus::MissingCarrier,
            "missing_charge" => ApiStatus::MissingCharge,
            "missing_choices" => ApiStatus::MissingChoices,
            "missing_city" => ApiStatus::MissingCity,
            "missing_client" => ApiStatus::MissingClient,
            "missing_cnam" => ApiStatus::MissingCNAM,
            "missing_codec" => ApiStatus::MissingCodec,
            "missing_conference" => ApiStatus::MissingConference,
            "missing_country" => ApiStatus::MissingCountry,
            "missing_countryid" => ApiStatus::MissingCountryid,
            "missing_credentials" => ApiStatus::MissingCredentials,
            "missing_datetime" => ApiStatus::MissingDatetime,
            "missing_delay_before" => ApiStatus::MissingDelayBefore,
            "missing_deletemessage" => ApiStatus::MissingDeletemessage,
            "missing_description" => ApiStatus::MissingDescription,
            "missing_devicetype" => ApiStatus::MissingDevicetype,
            "missing_dialtime" => ApiStatus::MissingDialtime,
            "missing_did" => ApiStatus::MissingDID,
            "missing_digits" => ApiStatus::MissingDigits,
            "missing_digit_timeout" => ApiStatus::MissingDigitTimeout,
            "missing_disa" => ApiStatus::MissingDISA,
            "missing_dtmfmode" => ApiStatus::MissingDtmfmode,
            "missing_email" => ApiStatus::MissingEmail,
            "missing_email_confirm" => ApiStatus::MissingEmailConfirm,
            "missing_enable" => ApiStatus::MissingEnable,
            "missing_endhour" => ApiStatus::MissingEndhour,
            "missing_endminute" => ApiStatus::MissingEndminute,
            "missing_failover_busy" => ApiStatus::MissingFailoverBusy,
            "missing_failover_noanswer" => ApiStatus::MissingFailoverNoanswer,
            "missing_failover_unreachable" => ApiStatus::MissingFailoverUnreachable,
            "missing_file" => ApiStatus::MissingFile,
            "missing_filter" => ApiStatus::MissingFilter,
            "missing_firstname" => ApiStatus::MissingFirstname,
            "missing_folder" => ApiStatus::MissingFolder,
            "missing_forwarding" => ApiStatus::MissingForwarding,
            "missing_from_date" => ApiStatus::MissingFromDate,
            "missing_fullname" => ApiStatus::MissingFullname,
            "missing_id" => ApiStatus::MissingID,
            "missing_if_announce_position_enabled_report_e" => {
                ApiStatus::MissingIfAnnouncePositionEnabledReportE
            }
            "missing_internationalroute" => ApiStatus::MissingInternationalroute,
            "missing_ip" => ApiStatus::MissingIP,
            "missing_ip_h323" => ApiStatus::MissingIPH323,
            "missing_ip_restriction" => ApiStatus::MissingIPRestriction,
            "missing_ivr" => ApiStatus::MissingIVR,
            "missing_join_when_empty" => ApiStatus::MissingJoinWhenEmpty,
            "missing_language" => ApiStatus::MissingLanguage,
            "missing_lastname" => ApiStatus::MissingLastname,
            "missing_leave_when_empty" => ApiStatus::MissingLeaveWhenEmpty,
            "missing_length" => ApiStatus::MissingLength,
            "missing_listened" => ApiStatus::MissingListened,
            "missing_location" => ApiStatus::MissingLocation,
            "missing_location_name" => ApiStatus::MissingLocationName,
            "missing_lockinternational" => ApiStatus::MissingLockinternational,
            "missing_mailbox" => ApiStatus::MissingMailbox,
            "missing_member" => ApiStatus::MissingMember,
            "missing_members" => ApiStatus::MissingMembers,
            "missing_message_num" => ApiStatus::MissingMessageNum,
            "missing_method" => ApiStatus::MissingMethod,
            "missing_minute" => ApiStatus::MissingMinute,
            "missing_monthly" => ApiStatus::MissingMonthly,
            "missing_musiconhold" => ApiStatus::MissingMusiconhold,
            "missing_name" => ApiStatus::MissingName,
            "missing_nat" => ApiStatus::MissingNAT,
            "missing_number" => ApiStatus::MissingNumber,
            "missing_numbers" => ApiStatus::MissingNumbers,
            "missing_package" => ApiStatus::MissingPackage,
            "missing_params" => ApiStatus::MissingParams,
            "missing_password" => ApiStatus::MissingPassword,
            "missing_password_confirm" => ApiStatus::MissingPasswordConfirm,
            "missing_payment" => ApiStatus::MissingPayment,
            "missing_phonebook" => ApiStatus::MissingPhonebook,
            "missing_phonenumber" => ApiStatus::MissingPhonenumber,
            "missing_pin" => ApiStatus::MissingPIN,
            "missing_playinstructions" => ApiStatus::MissingPlayinstructions,
            "missing_pop_restriction" => ApiStatus::MissingPOPRestriction,
            "missing_priority" => ApiStatus::MissingPriority,
            "missing_priority_weight" => ApiStatus::MissingPriorityWeight,
            "missing_protocol" => ApiStatus::MissingProtocol,
            "missing_province" => ApiStatus::MissingProvince,
            "missing_query" => ApiStatus::MissingQuery,
            "missing_recording" => ApiStatus::MissingRecording,
            "missing_report_hold_time_agent" => ApiStatus::MissingReportHoldTimeAgent,
            "missing_resellerclient" => ApiStatus::MissingResellerclient,
            "missing_resellerpackage" => ApiStatus::MissingResellerpackage,
            "missing_response_timeout" => ApiStatus::MissingResponseTimeout,
            "missing_ringgroup" => ApiStatus::MissingRinggroup,
            "missing_ring_inuse" => ApiStatus::MissingRingInuse,
            "missing_ring_strategy" => ApiStatus::MissingRingStrategy,
            "missing_route" => ApiStatus::MissingRoute,
            "missing_routing" => ApiStatus::MissingRouting,
            "missing_saycallerid" => ApiStatus::MissingSaycallerid,
            "missing_saytime" => ApiStatus::MissingSaytime,
            "missing_serverpop" => ApiStatus::MissingServerpop,
            "missing_setup" => ApiStatus::MissingSetup,
            "missing_sipuri" => ApiStatus::MissingSIPURI,
            "missing_skippassword" => ApiStatus::MissingSkippassword,
            "missing_sms" => ApiStatus::MissingSMS,
            "missing_speed_dial" => ApiStatus::MissingSpeedDial,
            "missing_start" => ApiStatus::MissingStart,
            "missing_starthour" => ApiStatus::MissingStarthour,
            "missing_startminute" => ApiStatus::MissingStartminute,
            "missing_state" => ApiStatus::MissingState,
            "missing_street_name" => ApiStatus::MissingStreetName,
            "missing_street_number" => ApiStatus::MissingStreetNumber,
            "missing_thankyou_for_your_patience" => ApiStatus::MissingThankyouForYourPatience,
            "missing_timecondition" => ApiStatus::MissingTimecondition,
            "missing_timeout" => ApiStatus::MissingTimeout,
            "missing_timezone" => ApiStatus::MissingTimezone,
            "missing_to_date" => ApiStatus::MissingToDate,
            "missing_transcription_email" => ApiStatus::MissingTranscriptionEmail,
            "missing_transcription_locale" => ApiStatus::MissingTranscriptionLocale,
            "missing_type" => ApiStatus::MissingType,
            "missing_urgent" => ApiStatus::MissingUrgent,
            "missing_uri" => ApiStatus::MissingURI,
            "missing_username" => ApiStatus::MissingUsername,
            "missing_voicemailsetup" => ApiStatus::MissingVoicemailsetup,
            "missing_weekdayend" => ApiStatus::MissingWeekdayend,
            "missing_weekdaystart" => ApiStatus::MissingWeekdaystart,
            "missing_zip" => ApiStatus::MissingZip,
            "moving_fail" => ApiStatus::MovingFail,
            "name_toolong" => ApiStatus::NameToolong,
            "non_sufficient_funds" => ApiStatus::NonSufficientFunds,
            "note_toolong" => ApiStatus::NoteToolong,
            "no_account" => ApiStatus::NoAccount,
            "no_attachments" => ApiStatus::NoAttachments,
            "no_base64file" => ApiStatus::NoBase64file,
            "no_callback" => ApiStatus::NoCallback,
            "no_callhunting" => ApiStatus::NoCallhunting,
            "no_callparking" => ApiStatus::NoCallparking,
            "no_callstatus" => ApiStatus::NoCallstatus,
            "no_cdr" => ApiStatus::NoCDR,
            "no_change_billingtype" => ApiStatus::NoChangeBillingtype,
            "no_client" => ApiStatus::NoClient,
            "no_conference" => ApiStatus::NoConference,
            "no_did" => ApiStatus::NoDID,
            "no_disa" => ApiStatus::NoDISA,
            "no_emailtofax" => ApiStatus::NoEmailtofax,
            "no_filter" => ApiStatus::NoFilter,
            "no_folder" => ApiStatus::NoFolder,
            "no_forwarding" => ApiStatus::NoForwarding,
            "no_ivr" => ApiStatus::NoIVR,
            "no_mailbox" => ApiStatus::NoMailbox,
            "no_member" => ApiStatus::NoMember,
            "no_message" => ApiStatus::NoMessage,
            "no_messages" => ApiStatus::NoMessages,
            "no_numbers" => ApiStatus::NoNumbers,
            "no_package" => ApiStatus::NoPackage,
            "no_phonebook" => ApiStatus::NoPhonebook,
            "no_phonebook_group" => ApiStatus::NoPhonebookGroup,
            "no_provision" => ApiStatus::NoProvision,
            "no_provision_update" => ApiStatus::NoProvisionUpdate,
            "no_queue" => ApiStatus::NoQueue,
            "no_rate" => ApiStatus::NoRate,
            "no_recording" => ApiStatus::NoRecording,
            "no_ringgroup" => ApiStatus::NoRinggroup,
            "no_sequences" => ApiStatus::NoSequences,
            "no_sipuri" => ApiStatus::NoSIPURI,
            "no_sms" => ApiStatus::NoSMS,
            "no_timecondition" => ApiStatus::NoTimecondition,
            "no_transactions" => ApiStatus::NoTransactions,
            "no_vpri" => ApiStatus::NoVPRI,
            "order_failed" => ApiStatus::OrderFailed,
            "problem_sending_mail" => ApiStatus::ProblemSendingMail,
            "provider_outofservice" => ApiStatus::ProviderOutofservice,
            "recording_in_use_caller_id_filtering" => ApiStatus::RecordingInUseCallerIDFiltering,
            "recording_in_use_caller_timecondition" => ApiStatus::RecordingInUseCallerTimecondition,
            "recording_in_use_did" => ApiStatus::RecordingInUseDID,
            "recording_in_use_ivr" => ApiStatus::RecordingInUseIVR,
            "recording_in_use_queue" => ApiStatus::RecordingInUseQueue,
            "repeated_ip" => ApiStatus::RepeatedIP,
            "reserved_ip" => ApiStatus::ReservedIP,
            "rtp_timeout_greater_than_rtp_hold_timeout" => {
                ApiStatus::RTPTimeoutGreaterThanRTPHoldTimeout
            }
            "same_did_billingtype" => ApiStatus::SameDIDBillingtype,
            "sent_fail" => ApiStatus::SentFail,
            "sipuri_in_phonebook" => ApiStatus::SIPURIInPhonebook,
            "sms_apply_regulations" => ApiStatus::SMSApplyRegulations,
            "sms_failed" => ApiStatus::SMSFailed,
            "sms_toolong" => ApiStatus::SMSToolong,
            "sms_wait_message" => ApiStatus::SMSWaitMessage,
            "tls_error" => ApiStatus::TlsError,
            "Unable_to_purchase" => ApiStatus::UnableToPurchase,
            "unavailable_info" => ApiStatus::UnavailableInfo,
            "unsifficient_stock" => ApiStatus::UnsifficientStock,
            "used_description" => ApiStatus::UsedDescription,
            "used_email" => ApiStatus::UsedEmail,
            "used_extension" => ApiStatus::UsedExtension,
            "used_extension_in_location" => ApiStatus::UsedExtensionInLocation,
            "used_filter" => ApiStatus::UsedFilter,
            "used_ip" => ApiStatus::UsedIP,
            "used_name" => ApiStatus::UsedName,
            "used_number" => ApiStatus::UsedNumber,
            "used_password" => ApiStatus::UsedPassword,
            "used_speed_dial" => ApiStatus::UsedSpeedDial,
            "used_username" => ApiStatus::UsedUsername,
            "weak_password" => ApiStatus::WeakPassword,
            other => ApiStatus::Unknown(other.to_string()),
        }
    }

    /// The human-readable description of this status from the
    /// VoIP.ms docs, or `None` for [`ApiStatus::Unknown`].
    pub fn description(&self) -> Option<&'static str> {
        match self {
            ApiStatus::AccountWithDIDs => Some("The Account has DIDs assigned to it."),
            ApiStatus::APILimitExceeded => Some("API requests limit per minute has been reached"),
            ApiStatus::APINotEnabled => Some("API has not been enabled or has been disabled"),
            ApiStatus::CancelFailed => Some("The cancellation wasn't completed."),
            ApiStatus::CANHaveOnlyOneProfileWithoutPIN => {
                Some("The conference can just have one profile member without pin")
            }
            ApiStatus::ConferenceMemberRelationNotFound => {
                Some("There is no relation between the profile member and the conference.")
            }
            ApiStatus::DIDInUse => Some("DID Number is already in use"),
            ApiStatus::DIDLimitReached => Some(
                "You have reached the maximum number of DID numbers allowed for your account type. Please contact our team if you have a specific use case or if you would like to upgrade to a Business account.",
            ),
            ApiStatus::DuplicatedName => Some("There is already another entry with this name"),
            ApiStatus::DuplicatedPIN => Some("The given pin has been duplicated"),
            ApiStatus::E911Disabled => Some("DID e911 service it's not enabled."),
            ApiStatus::E911Pending => {
                Some("DID e911 service has been requested and is in validation process.")
            }
            ApiStatus::ErrorDeletingMsg => Some("Error when deleting message"),
            ApiStatus::ErrorMovingMsg => Some("Error when move the voicemail message to folder"),
            ApiStatus::ExceedsFileSize => Some("The file exceeds the limite size allowed."),
            ApiStatus::ExistingDID => {
                Some("You can't set a callback to an existing VoIP.ms DID number")
            }
            ApiStatus::ForwardsExceeded => Some("Your account is limited to 4 forward entries"),
            ApiStatus::InvalidAccount => Some("This is not a valid account"),
            ApiStatus::InvalidAddress => Some("Address is missing or the format is invalid."),
            ApiStatus::InvalidAdmin => Some("This is not a valid admin"),
            ApiStatus::InvalidAgentRingTimeout => {
                Some("This is not a valid Agent ring time out value")
            }
            ApiStatus::InvalidAllowedcodecs => {
                Some("One of the codecs provided is invalid Format and Values: ulaw;g729;gsm;all")
            }
            ApiStatus::InvalidAnnounceJoinLeave => {
                Some("This is not a valid \"Announce join leave\"")
            }
            ApiStatus::InvalidAnnounceOnlyUser => {
                Some("This is not a valid \"Announce only user\"")
            }
            ApiStatus::InvalidAnnouncePositionFrequency => {
                Some("This is not a valid Announce position frequency")
            }
            ApiStatus::InvalidAnnounceRoundSeconds => {
                Some("This is not a valid \"Announce round seconds\"")
            }
            ApiStatus::InvalidAnnounceUserCount => {
                Some("This is not a valid \"Announce user count\"")
            }
            ApiStatus::InvalidAreaCode => Some("this is not a valid Area Code."),
            ApiStatus::InvalidAttachid => Some("The given ID is invalid or doesn't exist."),
            ApiStatus::InvalidAttachmessage => {
                Some("this is not a valid AttachMessage Should be: yes/no")
            }
            ApiStatus::InvalidAttachFile => Some("Valid formats: PDF, MS Word, BMP, JPG"),
            ApiStatus::InvalidAuthtype => Some("This is not a valid Auth Type"),
            ApiStatus::InvalidAuthtypeH323 => Some("You must select IP Auth to use H.323"),
            ApiStatus::InvalidAuthtypeIax2 => {
                Some("You must use User/Password Authentication for IAX2")
            }
            ApiStatus::InvalidBalancemanagement => Some("This is not a valid BalanceManagement"),
            ApiStatus::InvalidBaseRecording => Some("This is not a valid recording path"),
            ApiStatus::InvalidBillingtype => {
                Some("This is not a valid Billing Type Allowed values: 1 = PerMinute, 2 = Flat")
            }
            ApiStatus::InvalidCallback => Some("This is not a valid Callback"),
            ApiStatus::InvalidCallbackEnable => Some("This is not a valid Callback enable value"),
            ApiStatus::InvalidCallbackRetry => Some("This is not a valid Callback retry"),
            ApiStatus::InvalidCallerid => Some("This is not a valid CallerID"),
            ApiStatus::InvalidCalleridprefix => {
                Some("This is not a valid CID Prefix, lenght should be less than 20 chars")
            }
            ApiStatus::InvalidCalleridOverride => Some("This is not a valid CallerID Override"),
            ApiStatus::InvalidCallhunting => Some("This is not a valid Call Hunting"),
            ApiStatus::InvalidCallparking => Some("This is not a valid Call Parking"),
            ApiStatus::InvalidCallrecording => Some("This is not a valid Call recording"),
            ApiStatus::InvalidCallType => Some("Call Type is not valid."),
            ApiStatus::InvalidCanadaRouting => Some("This is not a valid Canada Route"),
            ApiStatus::InvalidCarrier => Some("This is not a valid Carrier"),
            ApiStatus::InvalidCharge => Some("This is not a valid Charge"),
            ApiStatus::InvalidCity => Some("City is missing or the format is invalid."),
            ApiStatus::InvalidClient => Some("This is not a valid Client"),
            ApiStatus::InvalidCNAM => Some("This is not a valid CNAM Should be: 1/0"),
            ApiStatus::InvalidCodec => Some("This is not a valid Codec"),
            ApiStatus::InvalidConference => Some("This is not a valid Conference ID"),
            ApiStatus::InvalidContact => Some("This is not a valid Contact Number"),
            ApiStatus::InvalidCountry => Some(
                "Country is missing or the format is invalid, must be in format ISO 3166-1 alpha-2, example: US, CA, etc. (You can use the values returned by the method getCountries)",
            ),
            ApiStatus::InvalidCountryid => Some("This is not a valid Country ID"),
            ApiStatus::InvalidCredentials => Some("Username or Password is incorrect"),
            ApiStatus::InvalidDate => Some("This is not a valid date Format is: yyyy-mm-dd"),
            ApiStatus::InvalidDaterange => Some("Date Range should be 92 days or less"),
            ApiStatus::InvalidDatetime => {
                Some("This is not a valid datetime Format is: yyyy-mm-dd hh:mm:ss")
            }
            ApiStatus::InvalidDateFrom => {
                Some("The \"From\" date should be prior to the \"To\" date.")
            }
            ApiStatus::InvalidDayrange => Some("This is not a valid Day Range"),
            ApiStatus::InvalidDelayBefore => Some("This is not a valid DelayBefore"),
            ApiStatus::InvalidDeletemessage => {
                Some("This is not a valid DeleteMessage Should be: yes/no")
            }
            ApiStatus::InvalidDescription => Some("This is not a valid Description"),
            ApiStatus::InvalidDestination => Some("This is not a valid Destination"),
            ApiStatus::InvalidDestinationFolder => Some("This is not a valid Destination Folder"),
            ApiStatus::InvalidDevicetype => Some("This is not a valid Device Type"),
            ApiStatus::InvalidDialtime => Some("This is not a valid Dialtime"),
            ApiStatus::InvalidDID => Some("This is not a valid DID"),
            ApiStatus::InvalidDigits => {
                Some("These are not valid DigitsOrderDIDVirtual: Digits must be 3 numbers")
            }
            ApiStatus::InvalidDigitTimeout => Some("This is not a valid DigitTimeOut"),
            ApiStatus::InvalidDISA => Some("This is not a valid DISA"),
            ApiStatus::InvalidDiversionHeader => Some(
                "This is not a valid Diversion Header. It must be a numeric value, accepting only 0 or 1.",
            ),
            ApiStatus::InvalidDropSilence => Some("This is not a valid \"drop silence\" value"),
            ApiStatus::InvalidDST => Some("This is not a valid Destination Number"),
            ApiStatus::InvalidDtmfmode => Some("This is no a valid DTMF Mode"),
            ApiStatus::InvalidDTMFDigits => Some("This is no a valid DTMF digit"),
            ApiStatus::InvalidEmail => {
                Some("This is not a valid email or email is already in database")
            }
            ApiStatus::InvalidEmailAttachmentFormat => Some("This is not a valid format value"),
            ApiStatus::InvalidEmailEnable => Some("This is not a valid email enable value"),
            ApiStatus::InvalidEnableIPRestriction => {
                Some("This is not a valid Enable IP Restriction value")
            }
            ApiStatus::InvalidEnablePOPRestriction => {
                Some("This is not a valid Enable POP Restriction value")
            }
            ApiStatus::InvalidEndhour => Some("This is not a valid End Hour"),
            ApiStatus::InvalidEndminute => Some("This is not a valid End Minute"),
            ApiStatus::InvalidExtension => {
                Some("This is not a valid extension Extension can only contain digits")
            }
            ApiStatus::InvalidExtensions => Some(
                "Extensions cannot be: 098, 211, 311, 411, 4443, 4444, 4747, 511, 711, 811, 822, 911, 988",
            ),
            ApiStatus::InvalidExtensionLength => {
                Some("Extensions should not contain more than 5 digits")
            }
            ApiStatus::InvalidExtensionPrefix => Some("Extensions cannot start with: 068, 097"),
            ApiStatus::InvalidFailoverHeader => {
                Some("This is not a valid failover header Should be: account/vm/fwd/none")
            }
            ApiStatus::InvalidFAXID => Some("This is not a valid Fax Message ID"),
            ApiStatus::InvalidFile => Some("This is not a valid File"),
            ApiStatus::InvalidFilter => Some("This is not a valid Filter"),
            ApiStatus::InvalidFirstname => Some("First name is missing or the format is invalid."),
            ApiStatus::InvalidFocEnddate => {
                Some("Invalid date format, must be: YYYY-mm-dd. Example: 2018-02-22")
            }
            ApiStatus::InvalidFocStartdate => {
                Some("Invalid date format, must be: YYYY-mm-dd. Example: 2018-02-22")
            }
            ApiStatus::InvalidFolder => Some("This is not a valid Folder"),
            ApiStatus::InvalidFolderID => Some("This is not a valid Fax Folder ID"),
            ApiStatus::InvalidForwarding => Some("This is not a valid forwarding"),
            ApiStatus::InvalidForwardingDID => Some("Forwarding to the same did is not allowed"),
            ApiStatus::InvalidForwardEnable => Some("This is not a valid forward enable value"),
            ApiStatus::InvalidFrequencyAnnouncement => {
                Some("This is not a valid Frequency announce")
            }
            ApiStatus::InvalidFromNumber => Some("This is not a valid sender number."),
            ApiStatus::InvalidFullname => Some("This is not a valid Full Name"),
            ApiStatus::InvalidID => Some("This is not a valid ID"),
            ApiStatus::InvalidIfAnnouncePositionEnabledReportE => {
                Some("This is not a Report estimated hold time type")
            }
            ApiStatus::InvalidInternaldialtime => {
                Some("This is not a valid Internal Dialtime Should be: 1 to 60")
            }
            ApiStatus::InvalidInternalvoicemail => Some("This is not a valid Internal Voicemail"),
            ApiStatus::InvalidInternationalroute => Some("This is not a valid International Route"),
            ApiStatus::InvalidInvoiceType => {
                Some("Invalid invoice type, possible values: 0 = US, 1 = CAN.")
            }
            ApiStatus::InvalidIP => Some("This is an invalid IP"),
            ApiStatus::InvalidIPAuth => {
                Some("Do not provide an IP address for User/Pass Authentication")
            }
            ApiStatus::InvalidIPIax2 => Some("Do not provide an IP address for IAX2"),
            ApiStatus::InvalidIVR => Some("This is not a valid IVR"),
            ApiStatus::InvalidJitterBuffer => Some("This is not a valid \"jitter buffer\" value"),
            ApiStatus::InvalidJoinAnnouncement => {
                Some("This is not a valid 'Join Announcement' Type for a Queue")
            }
            ApiStatus::InvalidJoinEmptyType => {
                Some("This is not a valid 'JoinWhenEmpty' Type for a Queue")
            }
            ApiStatus::InvalidLanguage => Some("This is not a valid Language Should be: es/en/fr"),
            ApiStatus::InvalidLastname => Some("Lastname is missing or the format is invalid."),
            ApiStatus::InvalidListened => Some("This is not a valid Listened value"),
            ApiStatus::InvalidLocation => Some("This is not a valid Location"),
            ApiStatus::InvalidLockinternational => Some("This is not a valid Lock International"),
            ApiStatus::InvalidMailbox => Some("This is not a valid mailbox"),
            ApiStatus::InvalidMaximumCallers => Some("This is not a valid maximum callers value"),
            ApiStatus::InvalidMaximumWaitTime => {
                Some("This is not a valid maximum wait time value")
            }
            ApiStatus::InvalidMaxExpiry => {
                Some("This is not a valid Max Expiry (value must be between 60 and 3600 seconds)")
            }
            ApiStatus::InvalidMember => Some("This is not a valid Member"),
            ApiStatus::InvalidMemberDelay => Some("This is not a valid Member Delay"),
            ApiStatus::InvalidMessageNum => Some("This is not a valid Voicemail Message Number"),
            ApiStatus::InvalidMethod => Some("This is not a valid Method"),
            ApiStatus::InvalidMinute => Some("This is not a valid Minute Rate"),
            ApiStatus::InvalidMixedNumbers => {
                Some("Toll-free numbers and local numbers can not be mixed in the same order.")
            }
            ApiStatus::InvalidMonthly => Some("This is not a valid Montly Fee"),
            ApiStatus::InvalidMusiconhold => Some("This is not a valid Music on Hold"),
            ApiStatus::InvalidName => Some("This is not a valid name, Alphanumeric Only"),
            ApiStatus::InvalidNAT => Some("This is not a valid NAT"),
            ApiStatus::InvalidNote => {
                Some("This is not a valid Note, lenght should be less than 50 chars")
            }
            ApiStatus::InvalidNumber => Some("This is not a valid Number"),
            ApiStatus::InvalidNumbermembers => Some(
                "The element format of multiple data is not correct or it size does not match with other elements",
            ),
            ApiStatus::InvalidNumberCanadian => {
                Some("You have entered a Canadian number (not valid in this portability process).")
            }
            ApiStatus::InvalidNumberExist => Some("The number is already in our network"),
            ApiStatus::InvalidNumberFAX => {
                Some("The Fax number can not be ported into our network")
            }
            ApiStatus::InvalidNumberPorttype => {
                Some("You have entered a local number (not valid in this portability process)")
            }
            ApiStatus::InvalidNumberUS => {
                Some("You have entered a USA number (not valid in this portability process).")
            }
            ApiStatus::InvalidOrder => Some("This is not a valid \"order\" value"),
            ApiStatus::InvalidPackage => Some("This is not a valid Package"),
            ApiStatus::InvalidPassword => Some(
                "This is not a valid passwordVoicemail: Must be 4 Digits SubAccounts: More than 6 chars, Must Contain Alphanumeric and !#$%&/()=?*[]_:.,{}+-",
            ),
            ApiStatus::InvalidPasswordAuth => {
                Some("Do not provide a Password for IP Authentication")
            }
            ApiStatus::InvalidPasswordIlegalCharacters => Some(
                "This is not a valid password (Allowed characters: Alphanumeric and ! # $ % & / ( ) = ? * [ ] _ : . , { } + -)",
            ),
            ApiStatus::InvalidPasswordLessthan8charactersLong => {
                Some("This is not a valid password (Less than 8 characters long)")
            }
            ApiStatus::InvalidPasswordMissingLowercase => {
                Some("This is not a valid password (Missing lower case character)")
            }
            ApiStatus::InvalidPasswordMissingNumber => {
                Some("This is not a valid password (Missing a number)")
            }
            ApiStatus::InvalidPasswordMissingUppercase => {
                Some("This is not a valid password (Missing upper case character)")
            }
            ApiStatus::InvalidPause => Some("This is not a valid Pause"),
            ApiStatus::InvalidPayment => Some("This is not a valid Payment"),
            ApiStatus::InvalidPhonebook => Some("This is not a valid Phonebook"),
            ApiStatus::InvalidPhonenumber => Some("This is not a valid Phone Number"),
            ApiStatus::InvalidPIN => Some("This is not a valid PIN"),
            ApiStatus::InvalidPINNumber => Some("Must provide the account PIN number."),
            ApiStatus::InvalidPlayinstructions => {
                Some("This is not a valid PlayInstructions Should be: u/su")
            }
            ApiStatus::InvalidPOPRestriction => Some("This is not a valid POP Restriction"),
            ApiStatus::InvalidPortingid => Some("The given ID is invalid or doesn't exist."),
            ApiStatus::InvalidPorttype => Some("Must provide a valid port type."),
            ApiStatus::InvalidPortStatus => Some(
                "The status code is invalid. (You can use the values returned by the method getListStatus)",
            ),
            ApiStatus::InvalidPriority => Some("This is not a valid Priority"),
            ApiStatus::InvalidPriorityWeight => Some("This is not valid weight/priority value"),
            ApiStatus::InvalidProtocol => Some("This is not a valid Protocol"),
            ApiStatus::InvalidProviderAccount => {
                Some("You must provide your account # with the current provider")
            }
            ApiStatus::InvalidProviderName => Some("You must provide the service provider name"),
            ApiStatus::InvalidProvince => Some("This is not a valid Province"),
            ApiStatus::InvalidQuantity => Some("This is not a valid quantity"),
            ApiStatus::InvalidQuery => Some("This is not a valid Query"),
            ApiStatus::InvalidQueue => Some("This is not a valid Queue"),
            ApiStatus::InvalidQuiet => Some("This is not a valid \"quiet\" value"),
            ApiStatus::InvalidRecording => Some("This is not a valid recording"),
            ApiStatus::InvalidRecordingSoundErrorMenu => {
                Some("\"error menu\" is not a valid recording")
            }
            ApiStatus::InvalidRecordingSoundGetPIN => Some("\"get pin\" is not a valid recording"),
            ApiStatus::InvalidRecordingSoundHasJoined => {
                Some("\"has_joined\" is not a valid recording")
            }
            ApiStatus::InvalidRecordingSoundHasLeft => {
                Some("\"has_left\" is not a valid recording")
            }
            ApiStatus::InvalidRecordingSoundInvalidPIN => {
                Some("\"invalid pin\" is not a valid recording")
            }
            ApiStatus::InvalidRecordingSoundJoin => Some("\"join\" is not a valid recording"),
            ApiStatus::InvalidRecordingSoundKicked => Some("\"kicked\" is not a valid recording"),
            ApiStatus::InvalidRecordingSoundLeave => Some("\"leave\" is not a valid recording"),
            ApiStatus::InvalidRecordingSoundLocked => Some("\"locked\" is not a valid recording"),
            ApiStatus::InvalidRecordingSoundLockedNow => {
                Some("\"locked now\" is not a valid recording")
            }
            ApiStatus::InvalidRecordingSoundMuted => Some("\"muted\" is not a valid recording"),
            ApiStatus::InvalidRecordingSoundOnlyOne => {
                Some("\"only one\" is not a valid recording")
            }
            ApiStatus::InvalidRecordingSoundOnlyPerson => {
                Some("\"only person\" is not a valid recording")
            }
            ApiStatus::InvalidRecordingSoundOtherInParty => {
                Some("\"other in party\" is not a valid recording")
            }
            ApiStatus::InvalidRecordingSoundParticipantsMuted => {
                Some("\"participants muted\" is not a valid recording")
            }
            ApiStatus::InvalidRecordingSoundParticipantsUnmuted => {
                Some("\"participants unmuted\" is not a valid recording")
            }
            ApiStatus::InvalidRecordingSoundPlaceIntoConference => {
                Some("\"place into conference\" is not a valid recording")
            }
            ApiStatus::InvalidRecordingSoundThereAre => {
                Some("\"there are\" is not a valid recording")
            }
            ApiStatus::InvalidRecordingSoundUnlockedNow => {
                Some("\"unlocked now\" is not a valid recording")
            }
            ApiStatus::InvalidRecordingSoundUnmuted => Some("\"unmuted\" is not a valid recording"),
            ApiStatus::InvalidRecordCalls => Some("Record calls is not valid."),
            ApiStatus::InvalidReportHoldTimeAgent => {
                Some("This is not a valid Report hold time agent")
            }
            ApiStatus::InvalidResellerclient => Some("This is not a valid Reseller Client"),
            ApiStatus::InvalidResellernextbilling => Some(
                "This is not a valid Reseller Next Billing date, date should not be set in the past.",
            ),
            ApiStatus::InvalidResellerpackage => Some("This is not a valid Reseller Package"),
            ApiStatus::InvalidResponseTimeout => Some("This is not a valid ResponseTimeOut"),
            ApiStatus::InvalidRetryTimer => Some("This is not a valid Retry timer"),
            ApiStatus::InvalidRinggroup => Some("This is not a valid Ring group"),
            ApiStatus::InvalidRingInuse => Some("This is not a valid Ring in use value"),
            ApiStatus::InvalidRoute => Some("This is not a valid Route"),
            ApiStatus::InvalidRoutingHeader => {
                Some("This is not a valid Routing header Should be: account/vm/fwd")
            }
            ApiStatus::InvalidRTPHoldTimeout => Some(
                "This is not a valid RTP Hold Time Out (value must be between 1 and 3600 seconds)",
            ),
            ApiStatus::InvalidRTPTimeout => {
                Some("This is not a valid RTP Time Out (value must be between 1 and 3600 seconds)")
            }
            ApiStatus::InvalidSaycallerid => {
                Some("This is not a valid SayCallerID Should be: yes/no")
            }
            ApiStatus::InvalidSaytime => Some("This is not a valid SayTime Should be: yes/no"),
            ApiStatus::InvalidSecurityCode => {
                Some("This is not a valid Security Code. Should be alphanumeric.")
            }
            ApiStatus::InvalidServerpop => Some("This is not a valid Server POP"),
            ApiStatus::InvalidSetup => Some("This is not a valid Setup Fee"),
            ApiStatus::InvalidSilenceThreshold => {
                Some("This is not a valid \"silence threshold\" value")
            }
            ApiStatus::InvalidSIPURI => Some("This is not a valid SIPURI"),
            ApiStatus::InvalidSIPTraffic => Some("This is not a valid Encrypted SIP Traffic value"),
            ApiStatus::InvalidSkippassword => {
                Some("This is not a valid skippassword Should be: 1/0 - or - yes/no")
            }
            ApiStatus::InvalidSmppPassword => Some("This is not a valid SMPP Password"),
            ApiStatus::InvalidSmppURL => Some("This is not a valid SMPP URL"),
            ApiStatus::InvalidSmppUsername => Some("This is not a valid SMPP Username"),
            ApiStatus::InvalidSMS => Some("This is not a valid SMS"),
            ApiStatus::InvalidSMSForward => Some("This is not a valid SMS forward"),
            ApiStatus::InvalidSnn => Some("Must provide the 4 last digits of the SSN."),
            ApiStatus::InvalidSpeedDial => Some("This is not a valid Speed Dial"),
            ApiStatus::InvalidStarthour => Some("This is not a valid Start Hour"),
            ApiStatus::InvalidStartminute => Some("This is not a valid Start Minute"),
            ApiStatus::InvalidStartMuted => Some("This is not a valid Start Muted"),
            ApiStatus::InvalidState => Some("This is not a valid State"),
            ApiStatus::InvalidStatementName => {
                Some("Statement Name is missing or the format is invalid.")
            }
            ApiStatus::InvalidStrategy => Some("This is not a valid Ring Strategy"),
            ApiStatus::InvalidStreetName => Some("This is not a valid Street Name"),
            ApiStatus::InvalidStreetNumber => Some("This is not a valid Street Number"),
            ApiStatus::InvalidTalkingThreshold => {
                Some("This is not a valid \"talking threshold\" value")
            }
            ApiStatus::InvalidTalkDetection => Some("This is not a valid talk detection value"),
            ApiStatus::InvalidTfnumberPorttype => {
                Some("You have entered a toll-free number (not valid in this portability process).")
            }
            ApiStatus::InvalidThankyouForYourPatience => {
                Some("This is not a valid Thankyou for your patience value")
            }
            ApiStatus::InvalidThreshold => Some(
                "This is not a valid Threshold Amount. The Threshold Amount should be between 1 and 250",
            ),
            ApiStatus::InvalidTimecondition => Some("This is not a valid Time Condition"),
            ApiStatus::InvalidTimeout => Some("This is not a valid timeout"),
            ApiStatus::InvalidTimerange => Some("This is not a valid Timer Range"),
            ApiStatus::InvalidTimezone => Some(
                "This is not a valid TimezoneCDR and resellerCDR: Must be numeric Voicemail: Values from getTimezone",
            ),
            ApiStatus::InvalidToNumber => Some("This is not a valid destination number"),
            ApiStatus::InvalidTranscriptionEmail => Some("Transcription email is not valid"),
            ApiStatus::InvalidTranscriptionFormat => Some("Invalid Transcription Format"),
            ApiStatus::InvalidTranscriptionLocale => Some("Transcription locale is not valid."),
            ApiStatus::InvalidTranscriptionRedaction => Some("Invalid Transcription Redaction"),
            ApiStatus::InvalidTranscriptionSentiment => Some("Invalid Transcription Sentiment"),
            ApiStatus::InvalidTranscriptionSummary => Some("Invalid Transcription Summary"),
            ApiStatus::InvalidType => Some("This is not a valid Type"),
            ApiStatus::InvalidUrgent => Some("This is not valid urgent value"),
            ApiStatus::InvalidUsername => Some("This is not a valid Username"),
            ApiStatus::InvalidVoicemailsetup => Some("This is not a valid voicemail"),
            ApiStatus::InvalidVoiceAnnouncement => Some("This is not a valid Voice announce"),
            ApiStatus::InvalidWeekdayend => Some("This is not a valid Week End"),
            ApiStatus::InvalidWeekdaystart => Some("This is not a valid Week Start"),
            ApiStatus::InvalidWrapupTime => Some("This is not a valid Wrapup time"),
            ApiStatus::InvalidZip => Some("Zip Code is missing or the format is invalid."),
            ApiStatus::IPNotEnabled => Some("This IP is not enabled for API use"),
            ApiStatus::LimitReached => Some(
                "You have reached the maximum number of messages allowed per day. - SMS limit using the API. - Fax limit applies using any method.",
            ),
            ApiStatus::LocationAlreadyExists => Some("A location with this name already exists"),
            ApiStatus::LocationLinkedToSubaccount => {
                Some("This location is in use by one or more sub accounts and cannot be deleted")
            }
            ApiStatus::LocationNotFound => Some("The specified location could not be found"),
            ApiStatus::MaxPhonebook => {
                Some("Your account is limited to 8 SIP, IAX or SIP URI members")
            }
            ApiStatus::MembersExceeded => {
                Some("You have reached the maximum allowed entries for the Phonebook")
            }
            ApiStatus::MemberAlreadyIncluded => Some("The member has been included already"),
            ApiStatus::MessageEmpty => Some("The SMS Message is empty"),
            ApiStatus::MessageNotFound => Some("The voicemail message was not found"),
            ApiStatus::MethodMaintenance => Some("This API method is under maintenance"),
            ApiStatus::MismatchEmailConfirm => Some("e-mail confirm does not match with e-mail"),
            ApiStatus::MismatchPasswordConfirm => {
                Some("Pasword confirm does not match with Password")
            }
            ApiStatus::MissingAccount => Some("Account was not provided"),
            ApiStatus::MissingAddress => Some("Address was not provided"),
            ApiStatus::MissingAgentRingTimeout => Some("Agent ring time out was not provided"),
            ApiStatus::MissingAllowedcodecs => Some("Allowed Codecs were not provided"),
            ApiStatus::MissingAttachmessage => Some("AttachMessage was not provided"),
            ApiStatus::MissingAuthtype => Some("Auth Type was not provided"),
            ApiStatus::MissingBalancemanagement => Some("BalanceManagemente was not provided"),
            ApiStatus::MissingBillingtype => Some("Billing Type was not provided"),
            ApiStatus::MissingCallback => Some("Callback was not provided"),
            ApiStatus::MissingCallerid => Some("CallerID was not provided"),
            ApiStatus::MissingCallhunting => Some("Call hunting was not provided"),
            ApiStatus::MissingCallparking => Some("Call Parking was not provided"),
            ApiStatus::MissingCallrecording => Some("Call recording was not provided"),
            ApiStatus::MissingCarrier => Some("Carrier was not provided"),
            ApiStatus::MissingCharge => Some("Charge was not provided."),
            ApiStatus::MissingChoices => Some("Choices was not provided"),
            ApiStatus::MissingCity => Some("City was not provided"),
            ApiStatus::MissingClient => Some("Client was not provided"),
            ApiStatus::MissingCNAM => Some("CNAM was not provided"),
            ApiStatus::MissingCodec => Some("Codec was not provided"),
            ApiStatus::MissingConference => Some("Conference was not provided"),
            ApiStatus::MissingCountry => Some("Country was not provided"),
            ApiStatus::MissingCountryid => Some("Country ID was not provided"),
            ApiStatus::MissingCredentials => Some("Username or Password was not provided"),
            ApiStatus::MissingDatetime => Some("DateTime value was not provided"),
            ApiStatus::MissingDelayBefore => Some("DelayBefore was not provided"),
            ApiStatus::MissingDeletemessage => Some("DeleteMessage was not provided"),
            ApiStatus::MissingDescription => Some("Description was not provided"),
            ApiStatus::MissingDevicetype => Some("Device Type was not provided"),
            ApiStatus::MissingDialtime => Some("Dialtime was not provided"),
            ApiStatus::MissingDID => Some("DID was not provided"),
            ApiStatus::MissingDigits => Some("Digits were not provided"),
            ApiStatus::MissingDigitTimeout => Some("DigitTimeOut was not provided"),
            ApiStatus::MissingDISA => Some("DISA was not provided"),
            ApiStatus::MissingDtmfmode => Some("DTMF Mode was not provided"),
            ApiStatus::MissingEmail => Some("e-mail was not provided"),
            ApiStatus::MissingEmailConfirm => Some("e-mail confirm was not provided"),
            ApiStatus::MissingEnable => Some("Enable was not provided"),
            ApiStatus::MissingEndhour => Some("End Hour was not provided"),
            ApiStatus::MissingEndminute => Some("End Minute was not provided"),
            ApiStatus::MissingFailoverBusy => Some("Failover Busy was not provided"),
            ApiStatus::MissingFailoverNoanswer => Some("Failover NoAnswer was not provided"),
            ApiStatus::MissingFailoverUnreachable => Some("Failover Unreachable was not provided"),
            ApiStatus::MissingFile => Some("File was not provided"),
            ApiStatus::MissingFilter => Some("Filter was not provided"),
            ApiStatus::MissingFirstname => Some("Firstname was not provided"),
            ApiStatus::MissingFolder => Some("folder was not provided"),
            ApiStatus::MissingForwarding => Some("Forwarding was not provided"),
            ApiStatus::MissingFromDate => Some("From date was not provided"),
            ApiStatus::MissingFullname => Some("Full Name was not provided"),
            ApiStatus::MissingID => Some("ID was not provided"),
            ApiStatus::MissingIfAnnouncePositionEnabledReportE => Some(
                "If announce position enabled report estimated hold time' type was not provided",
            ),
            ApiStatus::MissingInternationalroute => Some("International Route was not provided"),
            ApiStatus::MissingIP => {
                Some("You need to provide an IP if you select IP Authentication Method")
            }
            ApiStatus::MissingIPH323 => Some("You must enter an IP Address for H.323"),
            ApiStatus::MissingIPRestriction => Some("IP Restriction was not provided"),
            ApiStatus::MissingIVR => Some("IVR was not provided"),
            ApiStatus::MissingJoinWhenEmpty => Some("JoinWhenEmpty' type was not provided"),
            ApiStatus::MissingLanguage => Some("Language was not provided"),
            ApiStatus::MissingLastname => Some("Lastname was not provided"),
            ApiStatus::MissingLeaveWhenEmpty => Some("LeaveWhenEmpty' type was not provided"),
            ApiStatus::MissingLength => Some("Length was not provided"),
            ApiStatus::MissingListened => Some("Listened code was not provided"),
            ApiStatus::MissingLocation => Some("Location was not provided"),
            ApiStatus::MissingLocationName => Some("Location Name Missing"),
            ApiStatus::MissingLockinternational => Some("Lock International was not provided"),
            ApiStatus::MissingMailbox => Some("Mailbox was not provided"),
            ApiStatus::MissingMember => Some("Member was not provided"),
            ApiStatus::MissingMembers => Some("You need at least 1 member to create a ring group"),
            ApiStatus::MissingMessageNum => Some("Voicemail message number was not provided"),
            ApiStatus::MissingMethod => {
                Some("Method must be provided when using the REST/JSON API")
            }
            ApiStatus::MissingMinute => Some("Minute Rate was not provided"),
            ApiStatus::MissingMonthly => Some("Monthly Fee was not provided"),
            ApiStatus::MissingMusiconhold => Some("Music on Hold was not provided"),
            ApiStatus::MissingName => Some("Name was not provided"),
            ApiStatus::MissingNAT => Some("NAT was not provided"),
            ApiStatus::MissingNumber => Some("Number was not provided"),
            ApiStatus::MissingNumbers => Some("You must enter at least one valid phone number."),
            ApiStatus::MissingPackage => Some("Package was not provided"),
            ApiStatus::MissingParams => Some("Required parameters were not provided"),
            ApiStatus::MissingPassword => Some("Password was not provided"),
            ApiStatus::MissingPasswordConfirm => Some("Password Confirm was not provided"),
            ApiStatus::MissingPayment => Some("Payment was not provided."),
            ApiStatus::MissingPhonebook => Some("Phonebook was not provided"),
            ApiStatus::MissingPhonenumber => Some("Phone Number was not provided"),
            ApiStatus::MissingPIN => Some("PIN was not provided"),
            ApiStatus::MissingPlayinstructions => Some("PlayInstructions was not provided"),
            ApiStatus::MissingPOPRestriction => Some("POP Restriction was not provided"),
            ApiStatus::MissingPriority => Some("Priority was not provided"),
            ApiStatus::MissingPriorityWeight => Some("Priority/Weight was not provided"),
            ApiStatus::MissingProtocol => Some("Protocol was not provided"),
            ApiStatus::MissingProvince => Some("Province was not provided"),
            ApiStatus::MissingQuery => Some("Query was not provided"),
            ApiStatus::MissingRecording => Some("Recording was not provided"),
            ApiStatus::MissingReportHoldTimeAgent => {
                Some("Report hold time agent was not provided")
            }
            ApiStatus::MissingResellerclient => {
                Some("Provide a Reseller Client or don't provide a Reseller Package")
            }
            ApiStatus::MissingResellerpackage => {
                Some("Provide a Reseller Package or don't provide a Reseller Client")
            }
            ApiStatus::MissingResponseTimeout => Some("ResponseTimeOut was not provided"),
            ApiStatus::MissingRinggroup => Some("Ring group was not provided"),
            ApiStatus::MissingRingInuse => Some("Ring in use was not provided"),
            ApiStatus::MissingRingStrategy => Some("Ring strategy was not provided"),
            ApiStatus::MissingRoute => Some("Route was not provided"),
            ApiStatus::MissingRouting => Some("Routing was not provided"),
            ApiStatus::MissingSaycallerid => Some("SayCallerID was not provided"),
            ApiStatus::MissingSaytime => Some("SayTime was not provided"),
            ApiStatus::MissingServerpop => Some("Server POP was not provided"),
            ApiStatus::MissingSetup => Some("Setup Fee was not provided"),
            ApiStatus::MissingSIPURI => Some("SIPURI was not provided"),
            ApiStatus::MissingSkippassword => Some("SkipPassword was not provided"),
            ApiStatus::MissingSMS => Some("SMS was not provided"),
            ApiStatus::MissingSpeedDial => Some("Speed Dial was not provided"),
            ApiStatus::MissingStart => Some("Start date was not provided"),
            ApiStatus::MissingStarthour => Some("Start Hour was not provided"),
            ApiStatus::MissingStartminute => Some("Start Minute was not provided"),
            ApiStatus::MissingState => Some("State was not provided"),
            ApiStatus::MissingStreetName => Some("Street Name was not provided"),
            ApiStatus::MissingStreetNumber => Some("Street Number was not provided"),
            ApiStatus::MissingThankyouForYourPatience => {
                Some("Thankyou for your patience was not provided")
            }
            ApiStatus::MissingTimecondition => Some("Time Condition was not provided"),
            ApiStatus::MissingTimeout => Some("Timeout was not provided"),
            ApiStatus::MissingTimezone => Some("Timezone was not provided"),
            ApiStatus::MissingToDate => Some("To date was not provided"),
            ApiStatus::MissingTranscriptionEmail => Some("Transcription email is required."),
            ApiStatus::MissingTranscriptionLocale => Some("Transcription locale is required."),
            ApiStatus::MissingType => Some("Type was not provided"),
            ApiStatus::MissingUrgent => Some("Urgent code was not provided"),
            ApiStatus::MissingURI => Some("URI was not provided"),
            ApiStatus::MissingUsername => Some("Username was not provided"),
            ApiStatus::MissingVoicemailsetup => Some("Voice mail setup was not provided"),
            ApiStatus::MissingWeekdayend => Some("Week End was not provide"),
            ApiStatus::MissingWeekdaystart => Some("Week Start was not provided"),
            ApiStatus::MissingZip => Some("Zip Code was not provided"),
            ApiStatus::MovingFail => Some("The Fax Message was not moved"),
            ApiStatus::NameToolong => Some("The name exceeds character size limit"),
            ApiStatus::NonSufficientFunds => {
                Some("Your account does not have sufficient funds to proceed")
            }
            ApiStatus::NoteToolong => Some("The note exceeds character size limit"),
            ApiStatus::NoAccount => Some("There are no accounts"),
            ApiStatus::NoAttachments => Some("Theres no attachments records to show."),
            ApiStatus::NoBase64file => Some("File not encoded in base64"),
            ApiStatus::NoCallback => Some("There are not Callbacks"),
            ApiStatus::NoCallhunting => Some("There are no Call Huntings"),
            ApiStatus::NoCallparking => Some("There are no Call Parking"),
            ApiStatus::NoCallstatus => Some(
                "No Call Status was provided. One of the following parameters needs to be set to \"1\": answered, noanswer, busy, failed",
            ),
            ApiStatus::NoCDR => Some("There are no CDR entries for the filter"),
            ApiStatus::NoChangeBillingtype => Some("Imposible change DID billing plan"),
            ApiStatus::NoClient => Some("There are no Clients"),
            ApiStatus::NoConference => Some("There are no Conferences"),
            ApiStatus::NoDID => Some("There are no DIDs"),
            ApiStatus::NoDISA => Some("There are no DISAs"),
            ApiStatus::NoEmailtofax => Some("There are no Email to Fax entries"),
            ApiStatus::NoFilter => Some("There are no Filters"),
            ApiStatus::NoFolder => Some("There are no Fax Folders"),
            ApiStatus::NoForwarding => Some("There was no Forwarding"),
            ApiStatus::NoIVR => Some("There are no ivr"),
            ApiStatus::NoMailbox => Some("There are no Mailboxes"),
            ApiStatus::NoMember => Some("There are no Static Members"),
            ApiStatus::NoMessage => Some("There are no Fax Message(s)"),
            ApiStatus::NoMessages => Some("There are no Voicemail Message(s)"),
            ApiStatus::NoNumbers => Some("There are no Fax Numbers"),
            ApiStatus::NoPackage => Some("there are no Packages"),
            ApiStatus::NoPhonebook => Some("There are no Phonebook entries"),
            ApiStatus::NoPhonebookGroup => Some("There are no Phonebook Groups"),
            ApiStatus::NoProvision => Some(
                "E911 service wasn't activated, this response comes with a description of the error.",
            ),
            ApiStatus::NoProvisionUpdate => Some(
                "E911 service wasn't updated, this response comes with a description of the error.",
            ),
            ApiStatus::NoQueue => Some("There are no Queue entries"),
            ApiStatus::NoRate => Some("There are no Rates"),
            ApiStatus::NoRecording => Some("There are no recordings"),
            ApiStatus::NoRinggroup => Some("There are no Ring groups"),
            ApiStatus::NoSequences => Some("No sequence has been found"),
            ApiStatus::NoSIPURI => Some("There are no SIP URIs"),
            ApiStatus::NoSMS => Some("There are no SMS messages"),
            ApiStatus::NoTimecondition => Some("There are no Time Conditions"),
            ApiStatus::NoTransactions => Some("There are no transactions"),
            ApiStatus::NoVPRI => Some("There are no vPRIs"),
            ApiStatus::OrderFailed => Some("The order wasn't completed."),
            ApiStatus::ProblemSendingMail => Some("There was a problem sending an email."),
            ApiStatus::ProviderOutofservice => Some("One of our providers is out of service"),
            ApiStatus::RecordingInUseCallerIDFiltering => {
                Some("You have a Caller ID Filtering using this Recording")
            }
            ApiStatus::RecordingInUseCallerTimecondition => {
                Some("You have a Time Condition using this Recording")
            }
            ApiStatus::RecordingInUseDID => Some("You have a DID using this Recording"),
            ApiStatus::RecordingInUseIVR => Some("You have an IVR using this Recording"),
            ApiStatus::RecordingInUseQueue => Some("You have a Calling Queue using this Recording"),
            ApiStatus::RepeatedIP => {
                Some("You already have a Subaccount using this IP and Protocol")
            }
            ApiStatus::ReservedIP => {
                Some("This is a reserved IP used by VoIP.ms or other Companies")
            }
            ApiStatus::RTPTimeoutGreaterThanRTPHoldTimeout => {
                Some("RTP Time Out can't be greater than RTP Hold Time Out")
            }
            ApiStatus::SameDIDBillingtype => {
                Some("The Billing Type provided and DID billing type are the same")
            }
            ApiStatus::SentFail => Some("The Fax Message it wasn't send."),
            ApiStatus::SIPURIInPhonebook => {
                Some("This SIPURI can't be deleted, it is mapped in the phonebook")
            }
            ApiStatus::SMSApplyRegulations => Some(
                "The number was not updated due to SMS regulations, please contact customer service for more information",
            ),
            ApiStatus::SMSFailed => Some("The SMS message was not sent"),
            ApiStatus::SMSToolong => Some("The SMS message exceeds 160 characters"),
            ApiStatus::SMSWaitMessage => Some(
                "SMS was not (Enabled/Disabled) for this DID, please wait a minute before you try again.",
            ),
            ApiStatus::TlsError => Some("Theres was a TLS error, please try later."),
            ApiStatus::UnableToPurchase => Some("Unable to purchase DIDs"),
            ApiStatus::UnavailableInfo => {
                Some("The information you requested is unavailable at this moment")
            }
            ApiStatus::UnsifficientStock => {
                Some("Theres no sufficient stock to complete the order.")
            }
            ApiStatus::UsedDescription => Some("You already have a record with this Description"),
            ApiStatus::UsedEmail => Some("You already have an entry with this Email"),
            ApiStatus::UsedExtension => Some("You already have a subaccount using this extension"),
            ApiStatus::UsedExtensionInLocation => {
                Some("You already have a subaccount using extension in this location")
            }
            ApiStatus::UsedFilter => Some("You already have a record with this Filter"),
            ApiStatus::UsedIP => Some("There is already another customer using this IP Address"),
            ApiStatus::UsedName => Some("You already have an entry using this name"),
            ApiStatus::UsedNumber => Some("You already have a record with this Number"),
            ApiStatus::UsedPassword => {
                Some("This password has been used previously by this account.")
            }
            ApiStatus::UsedSpeedDial => Some("You have an entry with this Speed Dial"),
            ApiStatus::UsedUsername => Some("You already have a subaccount using this Username."),
            ApiStatus::WeakPassword => Some("This Password is too weak or too common"),
            ApiStatus::Unknown(_) => None,
        }
    }

    /// Whether this status is a documented code (not
    /// [`ApiStatus::Unknown`]).
    pub fn is_documented(&self) -> bool {
        !matches!(self, ApiStatus::Unknown(_))
    }

    /// Whether this status means "the requested collection is empty,"
    /// rather than a failure. VoIP.ms returns a distinct `no_*` status
    /// for each list method when the list has no entries; the typed
    /// `Client` methods treat such a status as a successful empty
    /// response (collection fields deserialize to `None`) instead of an
    /// [`crate::Error::Api`], while the `*_raw` methods still surface it
    /// verbatim. Codes that look like `no_*` but signal a real failure
    /// (`no_base64file`, `no_callstatus`, `no_provision`, ...) are not
    /// included.
    pub fn is_empty(&self) -> bool {
        matches!(
            self,
            ApiStatus::NoAccount
                | ApiStatus::NoAttachments
                | ApiStatus::NoCallback
                | ApiStatus::NoCallhunting
                | ApiStatus::NoCallparking
                | ApiStatus::NoCDR
                | ApiStatus::NoClient
                | ApiStatus::NoConference
                | ApiStatus::NoDID
                | ApiStatus::NoDISA
                | ApiStatus::NoEmailtofax
                | ApiStatus::NoFilter
                | ApiStatus::NoFolder
                | ApiStatus::NoForwarding
                | ApiStatus::NoIVR
                | ApiStatus::NoMailbox
                | ApiStatus::NoMember
                | ApiStatus::NoMessage
                | ApiStatus::NoMessages
                | ApiStatus::NoNumbers
                | ApiStatus::NoPackage
                | ApiStatus::NoPhonebook
                | ApiStatus::NoPhonebookGroup
                | ApiStatus::NoQueue
                | ApiStatus::NoRate
                | ApiStatus::NoRecording
                | ApiStatus::NoRinggroup
                | ApiStatus::NoSIPURI
                | ApiStatus::NoSMS
                | ApiStatus::NoTimecondition
                | ApiStatus::NoTransactions
                | ApiStatus::NoVPRI
        )
    }
}

impl std::fmt::Display for ApiStatus {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_str(self.as_str())
    }
}

impl From<String> for ApiStatus {
    fn from(s: String) -> Self {
        ApiStatus::from_wire(&s)
    }
}

impl From<&str> for ApiStatus {
    fn from(s: &str) -> Self {
        ApiStatus::from_wire(s)
    }
}

impl serde::Serialize for ApiStatus {
    fn serialize<S: serde::Serializer>(&self, s: S) -> std::result::Result<S::Ok, S::Error> {
        s.serialize_str(self.as_str())
    }
}

impl<'de> serde::Deserialize<'de> for ApiStatus {
    fn deserialize<D: serde::Deserializer<'de>>(d: D) -> std::result::Result<Self, D::Error> {
        let s = <String as serde::Deserialize>::deserialize(d)?;
        Ok(ApiStatus::from_wire(&s))
    }
}

/// \- Adds a Charge to a specific Reseller Client
///
/// Parameters for [`Client::add_charge`] (wire method `addCharge`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct AddChargeParams {
    /// ID for a specific Reseller Client (Example: 561115) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub client: Option<u64>,
    /// Amount of money that will be Debited from the customer (Example: 4.99)
    /// (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub charge: Option<rust_decimal::Decimal>,
    /// Charge Description
    #[serde(skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    /// Set to true if testing how adding charges works
    #[serde(
        skip_serializing_if = "crate::responses::is_false",
        serialize_with = "crate::responses::serialize_flag_01"
    )]
    pub test: bool,
}

/// \- Add an invoice file to a portability process.
///
/// Parameters for [`Client::add_lnp_file`] (wire method `addLNPFile`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct AddLNPFileParams {
    /// ID of the port previously created. (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub portid: Option<u64>,
    /// Base 64 code of the file to be attached (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub file: Option<String>,
}

/// \- Add one or more numbers to start a portability process.
///
/// Parameters for [`Client::add_lnp_port`] (wire method `addLNPPort`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct AddLNPPortParams {
    /// Digits from 1 to 4: 1: United States Local numbers 2: Canadian Local
    /// Numbers 3: US/CA Toll Free Numbers 4: United States Fax numbers 5:
    /// Canadian Fax Numbers (required)
    #[serde(skip_serializing_if = "Option::is_none", rename = "portType")]
    pub port_type: Option<u64>,
    /// DID(s) to port into VoIP.ms network (Example: 5552341234,5552341233). If
    /// you are porting more than one number, please separate them with commas.
    /// (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub numbers: Option<String>,
    /// If you have more then 1 number with your current carrier and not porting
    /// them all, choose yes. If you are porting all the numbers, choose no.
    /// Please note that you still need to include all numbers you want to port.
    /// If you have 2 numbers and want to port both, you need to include both
    /// numbers in the list of numbers to port. - (Values: 1 = true, 0 = false)
    /// \- Default: 0
    #[serde(
        skip_serializing_if = "Option::is_none",
        serialize_with = "crate::responses::serialize_opt_flag_01",
        rename = "isPartial"
    )]
    pub is_partial: Option<bool>,
    /// \- (Values: 1 = Business, 0 = Residential) - Default: 0
    #[serde(skip_serializing_if = "Option::is_none", rename = "locationType")]
    pub location_type: Option<LocationType>,
    /// \- (Values: 1 = All the numbers are mobile numbers, 0 = false) - Default:
    /// 0
    #[serde(
        skip_serializing_if = "Option::is_none",
        serialize_with = "crate::responses::serialize_opt_flag_01",
        rename = "isMobile"
    )]
    pub is_mobile: Option<bool>,
    /// PIN Number
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pin: Option<String>,
    /// \[Required If isMobile = 1\] BTN: It is the phone number to which all
    /// the other numbers of the customer are charged, in a consolidated
    /// telephone bill (instead of showing separate charges for each number you
    /// own). Please try to find the BTN on your invoice, and if you are unable
    /// to do so please contact the current provider to obtain it.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub btn: Option<String>,
    /// \[Required If isMobile = 1\] Please be specific and describe ALL
    /// remaining services with the current carrier. This includes DSL/Data
    /// services, Hunt Group services, etc. Any services NOT listed below may be
    /// disconnected upon completion of this port order.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub services: Option<String>,
    /// \[Required If portType = 3\] Values: 1 - American Carrier, American
    /// Callers Only, 2 - American Carrier, American and Canadian Callers
    /// allowed, 3 - Canadian Carrier
    #[serde(skip_serializing_if = "Option::is_none", rename = "tfType")]
    pub tf_type: Option<u64>,
    /// This is for Business numbers only. Please type your Company Name if
    /// applicable, otherwise leave it blank. (required)
    #[serde(skip_serializing_if = "Option::is_none", rename = "statementName")]
    pub statement_name: Option<String>,
    /// This is the "Customer First Name" as it appears on the CSR (Customer
    /// Service Record) of the losing carrier. Please Enter the first name of
    /// the owner of the number or the autorized contact. No company name must
    /// be entered in the field. (required)
    #[serde(skip_serializing_if = "Option::is_none", rename = "firstName")]
    pub first_name: Option<String>,
    /// This is the "Customer Last Name" as it appears on the CSR (Customer
    /// Service Record) of the losing carrier. Please Enter the last name of the
    /// owner of the number or the autorized contact. No company name must be
    /// entered in the field (required)
    #[serde(skip_serializing_if = "Option::is_none", rename = "lastName")]
    pub last_name: Option<String>,
    /// This is the "Customer Address" as it appears on the CSR (Customer
    /// Service Record) of the losing carrier. (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub address1: Option<String>,
    /// Optional Address information (e.g: Suite 343)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub address2: Option<String>,
    /// This is the "City" as it appears on the CSR (Customer Service Record) of
    /// the losing carrier. (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub city: Option<String>,
    /// This is the "ZIP or Postal Code" as it appears on the CSR (Customer
    /// Service Record) of the losing carrier. (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub zip: Option<String>,
    /// This is the "State or Province" as it appears on the CSR (Customer
    /// Service Record) of the losing carrier. (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub state: Option<String>,
    /// This is the "Country" as it appears on the CSR (Customer Service Record)
    /// of the losing carrier. (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub country: Option<String>,
    /// The name of your current service provider. (required)
    #[serde(skip_serializing_if = "Option::is_none", rename = "providerName")]
    pub provider_name: Option<String>,
    /// Your Account with your current service provider. (required)
    #[serde(skip_serializing_if = "Option::is_none", rename = "providerAccount")]
    pub provider_account: Option<String>,
    /// \- If you would like to include additional information regarding this
    /// port, you can use this parameter.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub notes: Option<String>,
}

/// \- Add Member to a Conference
///
/// Parameters for [`Client::add_member_to_conference`] (wire method `addMemberToConference`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct AddMemberToConferenceParams {
    /// Specific Member ID (Example: 6547) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub member: Option<u64>,
    /// Specific Conference ID (Example: 234) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub conference: Option<u64>,
}

/// \- Adds a Payment to a specific Reseller Client
///
/// Parameters for [`Client::add_payment`] (wire method `addPayment`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct AddPaymentParams {
    /// ID for a specific Reseller Client (Example: 561115) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub client: Option<u64>,
    /// Amount of money that will be Credited to the customer (Example: 4.99)
    /// (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub payment: Option<rust_decimal::Decimal>,
    /// Payment Description
    #[serde(skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    /// Set to true if testing how adding payments works
    #[serde(
        skip_serializing_if = "crate::responses::is_false",
        serialize_with = "crate::responses::serialize_flag_01"
    )]
    pub test: bool,
}

/// \- Assigns a Per Minute DID to a VPRI (Flat Rate DIDs can&rsquo;t be
/// assigned)
///
/// Parameters for [`Client::assign_did_vpri`] (wire method `assignDIDvPRI`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct AssignDIDvPRIParams {
    /// Id for specific Vpri (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub vpri: Option<u64>,
    /// DID Number to be assign into our Vpri (Example: 561115) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub did: Option<String>,
}

/// \- Backorder DID (CANADA) from a specific ratecenter and province.
///
/// Parameters for [`Client::back_order_did_can`] (wire method `backOrderDIDCAN`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct BackOrderDIDCANParams {
    /// Number of DIDs to be Ordered (Example: 3) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub quantity: Option<u64>,
    /// Canadian Province (values from getProvinces) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub province: Option<String>,
    /// USA Ratecenter (Values from getRateCentersUSA) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ratecenter: Option<String>,
    /// Main Routing for the DID (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub routing: Option<crate::Routing>,
    /// Busy Routing for the DID
    #[serde(skip_serializing_if = "Option::is_none")]
    pub failover_busy: Option<crate::Routing>,
    /// Unreachable Routing for the DID
    #[serde(skip_serializing_if = "Option::is_none")]
    pub failover_unreachable: Option<crate::Routing>,
    /// NoAnswer Routing for the DID
    #[serde(skip_serializing_if = "Option::is_none")]
    pub failover_noanswer: Option<crate::Routing>,
    /// Voicemail for the DID (Example: 101)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub voicemail: Option<String>,
    /// Point of Presence for the DID (Example: 5) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pop: Option<u64>,
    /// Dial Time Out for the DID (Example: 60 -> in seconds) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub dialtime: Option<u64>,
    /// CNAM for the DID (Boolean: 1/0) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cnam: Option<u64>,
    /// Caller ID Prefix for the DID
    #[serde(skip_serializing_if = "Option::is_none")]
    pub callerid_prefix: Option<String>,
    /// Note for the DID
    #[serde(skip_serializing_if = "Option::is_none")]
    pub note: Option<String>,
    /// Billing type for the DID (1 = Per Minute, 2 = Flat) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub billing_type: Option<DidBillingType>,
    /// Set to true if testing how Orders work - Orders can not be undone - When
    /// testing, no Orders are made routing, failover_busy, failover_unreachable
    /// and failover_noanswer can receive values in the following format =>
    /// header:record_id Where header could be: account, fwd, vm, sip, grp, ivr,
    /// sys, recording, queue, cb, tc, disa, none. Examples: account Used for
    /// routing calls to Sub Accounts You can get all sub accounts using the
    /// getSubAccounts function fwd Used for routing calls to Forwarding
    /// entries. You can get the ID right after creating a Forwarding with
    /// setForwarding or by requesting all forwardings entries with
    /// getForwardings. vm Used for routing calls to a Voicemail. You can get
    /// all voicemails and their IDs using the getVoicemails function sys System
    /// Options: hangup = Hangup the Call busy = Busy tone noservice = System
    /// Recording: Number not in service disconnected = System Recording: Number
    /// has been disconnected dtmf = DTMF Test echo = Sound Quality Test none
    /// Used to route calls to no action Examples: 'account:100001_VoIP'
    /// 'fwd:1026' 'vm:101' 'none:' 'sys:echo'
    #[serde(
        skip_serializing_if = "crate::responses::is_false",
        serialize_with = "crate::responses::serialize_flag_01"
    )]
    pub test: bool,
}

/// \- Backorder DID (USA) from a specific ratecenter and state.
///
/// Parameters for [`Client::back_order_did_usa`] (wire method `backOrderDIDUSA`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct BackOrderDIDUSAParams {
    /// Number of DIDs to be Ordered (Example: 3) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub quantity: Option<u64>,
    /// USA State (values from getStates) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub state: Option<String>,
    /// USA Ratecenter (Values from getRateCentersUSA) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ratecenter: Option<String>,
    /// Main Routing for the DID (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub routing: Option<crate::Routing>,
    /// Busy Routing for the DID
    #[serde(skip_serializing_if = "Option::is_none")]
    pub failover_busy: Option<crate::Routing>,
    /// Unreachable Routing for the DID
    #[serde(skip_serializing_if = "Option::is_none")]
    pub failover_unreachable: Option<crate::Routing>,
    /// NoAnswer Routing for the DID
    #[serde(skip_serializing_if = "Option::is_none")]
    pub failover_noanswer: Option<crate::Routing>,
    /// Voicemail for the DID (Example: 101)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub voicemail: Option<String>,
    /// Point of Presence for the DID (Example: 5) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pop: Option<u64>,
    /// Dial Time Out for the DID (Example: 60 -> in seconds) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub dialtime: Option<u64>,
    /// CNAM for the DID (Boolean: 1/0) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cnam: Option<u64>,
    /// Caller ID Prefix for the DID
    #[serde(skip_serializing_if = "Option::is_none")]
    pub callerid_prefix: Option<String>,
    /// Note for the DID
    #[serde(skip_serializing_if = "Option::is_none")]
    pub note: Option<String>,
    /// Billing type for the DID (1 = Per Minute, 2 = Flat) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub billing_type: Option<DidBillingType>,
    /// Set to true if testing how Orders work - Orders can not be undone - When
    /// testing, no Orders are made routing, failover_busy, failover_unreachable
    /// and failover_noanswer can receive values in the following format =>
    /// header:record_id Where header could be: account, fwd, vm, sip, grp, ivr,
    /// sys, recording, queue, cb, tc, disa, none. Examples: account Used for
    /// routing calls to Sub Accounts You can get all sub accounts using the
    /// getSubAccounts function fwd Used for routing calls to Forwarding
    /// entries. You can get the ID right after creating a Forwarding with
    /// setForwarding or by requesting all forwardings entries with
    /// getForwardings. vm Used for routing calls to a Voicemail. You can get
    /// all voicemails and their IDs using the getVoicemails function sys System
    /// Options: hangup = Hangup the Call busy = Busy tone noservice = System
    /// Recording: Number not in service disconnected = System Recording: Number
    /// has been disconnected dtmf = DTMF Test echo = Sound Quality Test none
    /// Used to route calls to no action Examples: 'account:100001_VoIP'
    /// 'fwd:1026' 'vm:101' 'none:' 'sys:echo'
    #[serde(
        skip_serializing_if = "crate::responses::is_false",
        serialize_with = "crate::responses::serialize_flag_01"
    )]
    pub test: bool,
}

/// \- Deletes a specific DID from your Account.
///
/// Parameters for [`Client::cancel_did`] (wire method `cancelDID`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct CancelDIDParams {
    /// DID to be canceled and deleted (Example: 5551234567) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub did: Option<String>,
    /// Comment for DID cancellation
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cancelcomment: Option<String>,
    /// Set to true if the DID is being ported out
    #[serde(
        skip_serializing_if = "Option::is_none",
        serialize_with = "crate::responses::serialize_opt_flag_01"
    )]
    pub portout: Option<bool>,
    /// Set to true if testing how cancellation works - Cancellation can not be
    /// undone - When testing, no changes are made
    #[serde(
        skip_serializing_if = "crate::responses::is_false",
        serialize_with = "crate::responses::serialize_flag_01"
    )]
    pub test: bool,
}

/// \- Deletes a specific Fax Number from your Account.
///
/// Parameters for [`Client::cancel_fax_number`] (wire method `cancelFaxNumber`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct CancelFAXNumberParams {
    /// ID for a specific Fax Number (Example: 923) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub id: Option<u64>,
    /// Set to true if testing how cancel a Fax Number
    #[serde(
        skip_serializing_if = "crate::responses::is_false",
        serialize_with = "crate::responses::serialize_flag_01"
    )]
    pub test: bool,
}

/// \- Connects a specific DID to a specific Reseller Client Sub Account
///
/// Parameters for [`Client::connect_did`] (wire method `connectDID`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct ConnectDIDParams {
    /// DID to be Connected to Reseler Sub Account (Example: 5551234567)
    /// (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub did: Option<String>,
    /// Reseller Sub Account (Example: '100001_VoIP') (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub account: Option<String>,
    /// Montly Fee for Reseller Client (Example: 3.50) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub monthly: Option<rust_decimal::Decimal>,
    /// Setup Fee for Reseller Client (Example: 1.99) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub setup: Option<rust_decimal::Decimal>,
    /// Minute Rate for Reseller Client (Example: 0.03) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub minute: Option<rust_decimal::Decimal>,
    /// Next billing date (Example: '2014-03-30')
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_billing: Option<String>,
    /// If set to true, the setup value will not be charged after Connect
    #[serde(
        skip_serializing_if = "Option::is_none",
        serialize_with = "crate::responses::serialize_opt_flag_01"
    )]
    pub dont_charge_setup: Option<bool>,
    /// If set to true, the monthly value will not be charged after Connect
    #[serde(
        skip_serializing_if = "Option::is_none",
        serialize_with = "crate::responses::serialize_opt_flag_01"
    )]
    pub dont_charge_monthly: Option<bool>,
}

/// \- Connects a specific FAX DID to a specific Reseller Client Sub Account
///
/// Parameters for [`Client::connect_fax`] (wire method `connectFAX`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct ConnectFAXParams {
    /// FAX DID to be Connected to Reseller Sub Account (Example: 5551234567)
    /// (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub did: Option<String>,
    /// Reseller Sub Account (Example: '100001_VoIP') (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub account: Option<String>,
    /// Montly Fee for Reseller Client (Example: 3.50) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub monthly: Option<rust_decimal::Decimal>,
    /// Setup Fee for Reseller Client (Example: 1.99) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub setup: Option<rust_decimal::Decimal>,
    /// Minute Rate for Reseller Client (Example: 0.03) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub minute: Option<rust_decimal::Decimal>,
    /// Next billing date (Example: '2014-03-30')
    #[serde(skip_serializing_if = "Option::is_none")]
    pub next_billing: Option<String>,
    /// If set to true, the setup value will not be charged after Connect
    #[serde(
        skip_serializing_if = "Option::is_none",
        serialize_with = "crate::responses::serialize_opt_flag_01"
    )]
    pub dont_charge_setup: Option<bool>,
    /// If set to true, the monthly value will not be charged after Connect
    #[serde(
        skip_serializing_if = "Option::is_none",
        serialize_with = "crate::responses::serialize_opt_flag_01"
    )]
    pub dont_charge_monthly: Option<bool>,
}

/// \- Adds a new Sub Account entry to your Account
///
/// Parameters for [`Client::create_sub_account`] (wire method `createSubAccount`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct CreateSubAccountParams {
    /// Username for the Sub Account (Example: 'VoIP') (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub username: Option<String>,
    /// Protocol used for the Sub Account (Values from getProtocols) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub protocol: Option<u64>,
    /// Sub Account Description (Example: 'VoIP Account')
    #[serde(skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    /// Authorization Type Code (Values from getAuthTypes) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub auth_type: Option<u64>,
    /// Sub Account Password (For Password Authentication)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub password: Option<String>,
    /// Sub Account IP (For IP Authentication)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ip: Option<String>,
    /// Device Type Code (Values from getDeviceTypes) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub device_type: Option<u64>,
    /// Caller ID Override
    #[serde(skip_serializing_if = "Option::is_none")]
    pub callerid_number: Option<String>,
    /// Route Code (Values from getRoutes)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub canada_routing: Option<String>,
    /// Lock International Code (Values from getLockInternational) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lock_international: Option<u64>,
    /// Route Code (Values from getRoutes) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub international_route: Option<u64>,
    /// Music on Hold Code (Values from getMusicOnHold) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub music_on_hold: Option<String>,
    /// Language for system messages, such as "Invalid Option" (Values from
    /// getLanguages)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub language: Option<String>,
    /// List of Allowed Codecs (Values from getAllowedCodecs) Codecs separated
    /// by semicolon (Example: ulaw;g729;gsm) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub allowed_codecs: Option<String>,
    /// DTMF Mode Code (Values from getDTMFModes) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub dtmf_mode: Option<DtmfMode>,
    /// NAT Mode Code (Values from getNAT) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub nat: Option<Nat>,
    /// Encrypted SIP Traffic (Boolean: 1/0)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sip_traffic: Option<u64>,
    /// Max Expiry between 60 and 3600 (Example: 3000)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_expiry: Option<u64>,
    /// RTP Time Out between 1 and 3600 (Example: 60)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub rtp_timeout: Option<u64>,
    /// RTP Hold Time Out between 1 and 3600 (Example: 600)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub rtp_hold_timeout: Option<u64>,
    /// List of IP Addresses, IP Addresses/Netmask, or Fully Qualified Domain
    /// Names to allow outgoing calls separated by commas (Example:
    /// 123.45.3.21,10.255.12.0/22,device.mydomain.com)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ip_restriction: Option<String>,
    /// Enable IP Restriction (Boolean: 1/0)
    #[serde(
        skip_serializing_if = "Option::is_none",
        serialize_with = "crate::responses::serialize_opt_flag_01"
    )]
    pub enable_ip_restriction: Option<bool>,
    /// List of POP Servers to allow outgoing calls separated by commas (values
    /// from getServersInfo. Example: 10,23,45)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pop_restriction: Option<String>,
    /// Enable POP Restriction (Boolean: 1/0)
    #[serde(
        skip_serializing_if = "Option::is_none",
        serialize_with = "crate::responses::serialize_opt_flag_01"
    )]
    pub enable_pop_restriction: Option<bool>,
    /// Sub Account Internal Extension (Example: 1 -> Creates 101)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub internal_extension: Option<String>,
    /// Sub Account Internal Voicemail (Example: 101)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub internal_voicemail: Option<String>,
    /// Sub Account Internal Dialtime (Example: 60 -> seconds)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub internal_dialtime: Option<String>,
    /// Reseller Account ID (Example: 561115)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub reseller_client: Option<String>,
    /// Reseller Package (Example: 92364)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub reseller_package: Option<String>,
    /// Reseller Next Billing Date (Example: '2012-12-31')
    #[serde(skip_serializing_if = "Option::is_none")]
    pub reseller_nextbilling: Option<String>,
    /// True if you want to charge Package Setup Fee after Save
    #[serde(skip_serializing_if = "Option::is_none")]
    pub reseller_chargesetup: Option<String>,
    /// Send BYE on successful transfer (Boolean: 1/0)
    #[serde(
        skip_serializing_if = "Option::is_none",
        serialize_with = "crate::responses::serialize_opt_flag_01"
    )]
    pub send_bye: Option<bool>,
    /// Record Calls (Boolean: 1/0)
    #[serde(
        skip_serializing_if = "Option::is_none",
        serialize_with = "crate::responses::serialize_opt_flag_01"
    )]
    pub record_calls: Option<bool>,
    /// Enable Call Transcription (Boolean: 1/0)
    #[serde(
        skip_serializing_if = "Option::is_none",
        serialize_with = "crate::responses::serialize_opt_flag_01"
    )]
    pub transcribe: Option<bool>,
    /// Transcription locale code (values from getLocales, comma separated for
    /// more than one locale up to 10 locales)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub transcription_locale: Option<String>,
    /// Call Transcription Email
    #[serde(skip_serializing_if = "Option::is_none")]
    pub transcription_email: Option<String>,
    /// Call Transcription Delay Seconds between 0 and 60, Increments of 5
    /// (Example: 10 -> seconds)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub transcription_start_delay: Option<u64>,
    /// Enable Internal CallerID
    #[serde(
        skip_serializing_if = "Option::is_none",
        serialize_with = "crate::responses::serialize_opt_flag_01"
    )]
    pub enable_internal_cnam: Option<bool>,
    /// Internal CallerID Name
    #[serde(skip_serializing_if = "Option::is_none")]
    pub internal_cnam: Option<String>,
    /// Allows you to dial outgoing calls using either the NANPA configuration
    /// or the E164 configuration. (Values: 0 = Use Main Account Setting, 1 =
    /// E164, 2 = NANPA)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub dialing_mode: Option<DialingMode>,
    /// This allows you to select the carrier to be used for outgoing calls to
    /// toll-free numbers. (Values: -1 = Use main account settings, 0 = Default
    /// server setting, 1 = US carrier, 2 = Canadian carrier)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tfcarrier: Option<TollFreeCarrier>,
    /// Location group for the internal extension (Values from getLocations)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub internal_extension_location: Option<u64>,
}

/// \- Adds a new Voicemail entry to your Account
///
/// Parameters for [`Client::create_voicemail`] (wire method `createVoicemail`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct CreateVoicemailParams {
    /// Digits used to create the voicemail (Example: 01) Minimum 1 digit,
    /// maximum 10 digits (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub digits: Option<u64>,
    /// Name for the Mailbox (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    /// Password for the Mailbox (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub password: Option<String>,
    /// True if Skipping Password (Boolean: 1/0) (required)
    #[serde(
        skip_serializing_if = "Option::is_none",
        serialize_with = "crate::responses::serialize_opt_flag_01"
    )]
    pub skip_password: Option<bool>,
    /// Email address for receiving messages, multiple email addresses are
    /// allowed if separated by a comma
    #[serde(skip_serializing_if = "Option::is_none")]
    pub email: Option<String>,
    /// Yes for Attaching WAV files to Message (Values: 'yes'/'no') (required)
    #[serde(
        skip_serializing_if = "Option::is_none",
        serialize_with = "crate::responses::serialize_opt_flag_yes_no"
    )]
    pub attach_message: Option<bool>,
    /// Yes for Deleting Messages (Values: 'yes'/'no') (required)
    #[serde(
        skip_serializing_if = "Option::is_none",
        serialize_with = "crate::responses::serialize_opt_flag_yes_no"
    )]
    pub delete_message: Option<bool>,
    /// Yes for Saying Time Stamp (Values: 'yes'/'no') (required)
    #[serde(
        skip_serializing_if = "Option::is_none",
        serialize_with = "crate::responses::serialize_opt_flag_yes_no"
    )]
    pub say_time: Option<bool>,
    /// Time Zone for Mailbox (Values from getTimeZones) (required)
    #[serde(
        skip_serializing_if = "Option::is_none",
        serialize_with = "crate::responses::serialize_opt_tz"
    )]
    pub timezone: Option<chrono_tz::Tz>,
    /// Yes for Saying the Caller ID (Values: 'yes'/'no') (required)
    #[serde(
        skip_serializing_if = "Option::is_none",
        serialize_with = "crate::responses::serialize_opt_flag_yes_no"
    )]
    pub say_callerid: Option<bool>,
    /// Code for Play Instructions Setting (Values from getPlayInstructions)
    /// (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub play_instructions: Option<PlayInstructions>,
    /// Code for Language (Values from getLanguages) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub language: Option<String>,
    /// Code for Email Attachment format (Values from
    /// getVoicemailAttachmentFormats)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub email_attachment_format: Option<EmailAttachmentFormat>,
    /// Recording for the Unavailable Message (values from getRecordings)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub unavailable_message_recording: Option<String>,
    /// 'yes' to enable Voicemail Transcription
    #[serde(
        skip_serializing_if = "Option::is_none",
        serialize_with = "crate::responses::serialize_opt_flag_yes_no"
    )]
    pub transcription: Option<bool>,
    /// Transcription locale code (values from getLocales, comma separated for
    /// more than one locale up to 10 locales)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub transcription_locale: Option<String>,
    /// Yes for Transcription redaction (Values: 'yes'/'no')
    #[serde(
        skip_serializing_if = "Option::is_none",
        serialize_with = "crate::responses::serialize_opt_flag_yes_no"
    )]
    pub transcription_redaction: Option<bool>,
    /// Yes for Transcription sentiment (Values: 'yes'/'no')
    #[serde(
        skip_serializing_if = "Option::is_none",
        serialize_with = "crate::responses::serialize_opt_flag_yes_no"
    )]
    pub transcription_sentiment: Option<bool>,
    /// Yes for Transcription summary (Values: 'yes'/'no')
    #[serde(
        skip_serializing_if = "Option::is_none",
        serialize_with = "crate::responses::serialize_opt_flag_yes_no"
    )]
    pub transcription_summary: Option<bool>,
    /// Transcription format ( Values: 'html'/'text')
    #[serde(skip_serializing_if = "Option::is_none")]
    pub transcription_format: Option<TranscriptionFormat>,
}

/// \- Deletes a specific Call Hunting from your Account.
///
/// Parameters for [`Client::del_call_hunting`] (wire method `delCallHunting`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct DelCallHuntingParams {
    /// ID for a specific Call Hunting (Example: 323) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub callhunting: Option<u64>,
}

/// \- Deletes a specific Call Parking entry from your Account.
///
/// Parameters for [`Client::del_call_parking`] (wire method `delCallParking`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct DelCallParkingParams {
    /// ID for a specific Call Parking (Example: 323) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub callparking: Option<u64>,
}

/// \- Delete specific call recording, audio file and information related.
///
/// Parameters for [`Client::del_call_recording`] (wire method `delCallRecording`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct DelCallRecordingParams {
    /// Call Recording (Values from getCallRecordings) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub callrecording: Option<String>,
    /// Filter Call Recordings by Account (Values from getCallAccounts)
    /// (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub account: Option<String>,
}

/// \- Deletes a specific Callback from your Account.
///
/// Parameters for [`Client::del_callback`] (wire method `delCallback`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct DelCallbackParams {
    /// ID for a specific Callback (Example: 19183) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub callback: Option<u64>,
}

/// \- Deletes a specific CallerID Filtering from your Account.
///
/// Parameters for [`Client::del_caller_id_filtering`] (wire method `delCallerIDFiltering`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct DelCallerIDFilteringParams {
    /// ID for a specific CallerID Filtering (Example: 19183) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub filtering: Option<u64>,
}

/// \- Deletes a specific reseller client from your Account.
///
/// Parameters for [`Client::del_client`] (wire method `delClient`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct DelClientParams {
    /// ID for a specific Reseller Client (Example: 1998) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub client: Option<u64>,
}

/// \- Deletes a specific Conference from your Account.
///
/// Parameters for [`Client::del_conference`] (wire method `delConference`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct DelConferenceParams {
    /// ID for a specific Conference (Example: 737) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub conference: Option<u64>,
}

/// \- Deletes a specific Member profile from your Account.
///
/// Parameters for [`Client::del_conference_member`] (wire method `delConferenceMember`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct DelConferenceMemberParams {
    /// ID for a specific Member Profile (Example: 737) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub member: Option<u64>,
}

/// \- Deletes a specific DISA from your Account.
///
/// Parameters for [`Client::del_disa`] (wire method `delDISA`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct DelDISAParams {
    /// ID for a specific DISA (Example: 19183) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub disa: Option<u64>,
}

/// \- Deletes a specific "Email to Fax configuration" from your Account.
///
/// Parameters for [`Client::del_email_to_fax`] (wire method `delEmailToFax`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct DelEmailToFAXParams {
    /// ID for a specific "Email To Fax Configuration" (Example: 923) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub id: Option<u64>,
    /// Set to true if testing how cancel a "Email To Fax Configuration"
    #[serde(
        skip_serializing_if = "crate::responses::is_false",
        serialize_with = "crate::responses::serialize_flag_01"
    )]
    pub test: bool,
}

/// \- Deletes a specific Fax Folder from your Account.
///
/// Parameters for [`Client::del_fax_folder`] (wire method `delFaxFolder`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct DelFAXFolderParams {
    /// ID for a specific Fax Folder (Example: 923) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub id: Option<u64>,
    /// Set to true if testing how to delete a Fax Folder
    #[serde(
        skip_serializing_if = "crate::responses::is_false",
        serialize_with = "crate::responses::serialize_flag_01"
    )]
    pub test: bool,
}

/// \- Deletes a specific Forwarding from your Account.
///
/// Parameters for [`Client::del_forwarding`] (wire method `delForwarding`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct DelForwardingParams {
    /// ID for a specific Forwarding (Example: 19183)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub forwarding: Option<u64>,
}

/// \- Deletes a specific IVR from your Account.
///
/// Parameters for [`Client::del_ivr`] (wire method `delIVR`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct DelIVRParams {
    /// ID for a specific IVR (Example: 19183) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ivr: Option<u64>,
}

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

/// \- Removes a member profile from a specific Conference from your Account
///
/// Parameters for [`Client::del_member_from_conference`] (wire method `delMemberFromConference`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct DelMemberFromConferenceParams {
    /// ID for a specific Member (Example: 101) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub member: Option<u64>,
    /// ID for a specific Conference (Example: 3829)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub conference: Option<u64>,
}

/// \- Deletes all messages in all servers from a specific Voicemail from your
/// Account
///
/// Parameters for [`Client::del_messages`] (wire method `delMessages`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct DelMessagesParams {
    /// ID for a specific Mailbox (Example: 1001) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub mailbox: Option<u64>,
    /// Name for specific Folder (Required if message id is passed, Example:
    /// 'INBOX', values from: getVoicemailFolders)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub folder: Option<VoicemailFolder>,
    /// ID for specific Voicemail Message (Required if folder is passed,
    /// Example: 1)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub message_num: Option<u64>,
}

/// \- Deletes a specific custom Music on Hold.
///
/// Parameters for [`Client::del_music_on_hold`] (wire method `delMusicOnHold`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct DelMusicOnHoldParams {
    /// Music on Hold Name (Values from getMusicOnHold) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub music_on_hold: Option<String>,
}

/// \- Deletes a specific Phonebook from your Account.
///
/// Parameters for [`Client::del_phonebook`] (wire method `delPhonebook`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct DelPhonebookParams {
    /// ID for a specific Phonebook (Example: 19183) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub phonebook: Option<u64>,
}

/// \- Deletes a specific Phonebook group from your Account.
///
/// Parameters for [`Client::del_phonebook_group`] (wire method `delPhonebookGroup`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct DelPhonebookGroupParams {
    /// ID for a specific Phonebook group (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub group: Option<String>,
}

/// \- Deletes a specific Queue from your Account.
///
/// Parameters for [`Client::del_queue`] (wire method `delQueue`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct DelQueueParams {
    /// ID for a specific Queue (Example: 13183) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub queue: Option<u64>,
}

/// \- Deletes a specific Recording from your Account.
///
/// Parameters for [`Client::del_recording`] (wire method `delRecording`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct DelRecordingParams {
    /// ID for a specific Recording (Example: 19183) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub recording: Option<u64>,
}

/// \- Deletes a specific Ring Group from your Account.
///
/// Parameters for [`Client::del_ring_group`] (wire method `delRingGroup`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct DelRingGroupParams {
    /// ID for a specific Ring Group (Example: 19183) (required)
    #[serde(skip_serializing_if = "Option::is_none", rename = "ringgroup")]
    pub ring_group: Option<u64>,
}

/// \- Deletes a specific SIP URI from your Account.
///
/// Parameters for [`Client::del_sip_uri`] (wire method `delSIPURI`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct DelSIPURIParams {
    /// ID for a specific SIP URI (Example: 19183) (required)
    #[serde(skip_serializing_if = "Option::is_none", rename = "sipuri")]
    pub sip_uri: Option<u64>,
}

/// \- Deletes a specific Static Member from Queue.
///
/// Parameters for [`Client::del_static_member`] (wire method `delStaticMember`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct DelStaticMemberParams {
    /// ID for a specific Member Queue (Example: 1918) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub member: Option<u64>,
    /// ID for a specific Queue (Example: 27183) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub queue: Option<u64>,
}

/// \- Deletes a specific Sub Account from your Account
///
/// Parameters for [`Client::del_sub_account`] (wire method `delSubAccount`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct DelSubAccountParams {
    /// ID for a specific Sub Account (Example: 99785)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub id: Option<u64>,
}

/// \- Deletes a specific Time Condition from your Account.
///
/// Parameters for [`Client::del_time_condition`] (wire method `delTimeCondition`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct DelTimeConditionParams {
    /// ID for a specific Time Condition (Example: 19183) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub timecondition: Option<u64>,
}

/// \- Deletes a specific Voicemail from your Account
///
/// Parameters for [`Client::del_voicemail`] (wire method `delVoicemail`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct DelVoicemailParams {
    /// ID for a specific Mailbox (Example: 1001) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub mailbox: Option<u64>,
}

/// \- Deletes a specific Fax Message from your Account.
///
/// Parameters for [`Client::delete_fax_message`] (wire method `deleteFaxMessage`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct DeleteFAXMessageParams {
    /// ID for a specific Fax Message (Example: 923) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub id: Option<u64>,
    /// Set to true if testing how cancel a Fax Message
    #[serde(
        skip_serializing_if = "crate::responses::is_false",
        serialize_with = "crate::responses::serialize_flag_01"
    )]
    pub test: bool,
}

/// \- Deletes a specific MMS from your Account.
///
/// Parameters for [`Client::delete_mms`] (wire method `deleteMMS`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct DeleteMMSParams {
    /// ID for a specific MMS (Example: 1918) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub id: Option<u64>,
}

/// \- Deletes a specific SMS from your Account.
///
/// Parameters for [`Client::delete_sms`] (wire method `deleteSMS`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct DeleteSMSParams {
    /// ID for a specific SMS (Example: 1918) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub id: Option<u64>,
}

/// \- Retrieves a list of e911 Address Types if no additional parameter is
/// provided.
/// \- Retrieves a specific e911 Address Type if an Address code is provided.
///
/// Parameters for [`Client::e911_address_types`] (wire method `e911AddressTypes`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct E911AddressTypesParams {
    /// Code for a specific Address Type (Example: Apartment)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub r#type: Option<String>,
}

/// \- Cancel the e911 Service from a specific DID.
///
/// Parameters for [`Client::e911_cancel`] (wire method `e911Cancel`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct E911CancelParams {
    /// DID to be canceled. (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub did: Option<String>,
}

/// \- Retrieves the e911 information from a specific DID.
///
/// Parameters for [`Client::e911_info`] (wire method `e911Info`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct E911InfoParams {
    /// DID with e911 enabled / in process. (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub did: Option<String>,
}

/// \- Subscribes your DID to the e911 Emergency Services.
///
/// Parameters for [`Client::e911_provision`] (wire method `e911Provision`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct E911ProvisionParams {
    /// DID that will be sent to the e911 service. (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub did: Option<String>,
    /// Full Name that will be sent to the e911 service. (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub full_name: Option<String>,
    /// Street Number that will be sent to the e911 service. (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub street_number: Option<u64>,
    /// Street Name that will be sent to the e911 service. (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub street_name: Option<String>,
    /// Address Type that will be sent to the e911 service (Values from
    /// e911AddressTypes).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub address_type: Option<String>,
    /// Address Number that will be sent to the e911 service.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub address_number: Option<u64>,
    /// City that will be sent to the e911 service. (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub city: Option<String>,
    /// State / Province that will be sent to the e911 service. (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub state: Option<String>,
    /// Country that will be sent to the e911 service. Value can be US (United
    /// states) or CA (Canada). (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub country: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub zip: Option<String>,
    /// Language that will be sent to the e911 service. Only available for
    /// addresses from Canada. Value can be EN (English) or FR (French).
    /// (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub language: Option<String>,
    /// Additional Address Information that will be sent to the e911 service.
    /// Only available for addresses from Canada.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub other_info: Option<String>,
}

/// \- Subscribes your DID to the e911 Emergency Services.
/// \- All e911 information will be validated by the VoIP.ms staff.
///
/// Parameters for [`Client::e911_provision_manually`] (wire method `e911ProvisionManually`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct E911ProvisionManuallyParams {
    /// DID that will be sent to the e911 service. (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub did: Option<String>,
    /// Full Name that will be sent to the e911 service. (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub full_name: Option<String>,
    /// Street Number that will be sent to the e911 service. (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub street_number: Option<u64>,
    /// Street Name that will be sent to the e911 service. (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub street_name: Option<String>,
    /// Address Type that will be sent to the e911 service (Values from
    /// e911AddressTypes).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub address_type: Option<String>,
    /// Address Number that will be sent to the e911 service.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub address_number: Option<u64>,
    /// City that will be sent to the e911 service. (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub city: Option<String>,
    /// State / Province that will be sent to the e911 service. (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub state: Option<String>,
    /// Country that will be sent to the e911 service. Value can be US (United
    /// states) or CA (Canada). (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub country: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub zip: Option<String>,
    /// Language that will be sent to the e911 service. Only available for
    /// addresses from Canada. Value can be EN (English) or FR (French).
    /// (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub language: Option<String>,
    /// Additional Address Information that will be sent to the e911 service.
    /// Only available for addresses from Canada.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub other_info: Option<String>,
}

/// \- Updates the Information from your e911 Emergency Services Subscription.
///
/// Parameters for [`Client::e911_update`] (wire method `e911Update`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct E911UpdateParams {
    /// DID with e911 enabled / in process. (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub did: Option<String>,
    /// Full Name that will be updated to the e911 service. (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub full_name: Option<String>,
    /// Street Number that will be updated to the e911 service. (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub street_number: Option<u64>,
    /// Street Name that will be updated to the e911 service. (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub street_name: Option<String>,
    /// Address Type that will be updated to the e911 service (Values from
    /// e911AddressTypes).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub address_type: Option<String>,
    /// Address Number that will be updated to the e911 service.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub address_number: Option<u64>,
    /// City that will be updated to the e911 service. (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub city: Option<String>,
    /// State / Province that will be updated to the e911 service. (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub state: Option<String>,
    /// Country that will be updated to the e911 service. Value can be US
    /// (United states) or CA (Canada). (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub country: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub zip: Option<String>,
    /// Language that will be updated to the e911 service. Only available for
    /// addresses from Canada. Value can be EN (English) or FR (French).
    /// (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub language: Option<String>,
    /// Additional Address Information that will be updated to the e911 service.
    /// Only available for addresses from Canada.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub other_info: Option<String>,
}

/// \- Validates your e911 information in order to start your e911 Emergency
/// Services Subscription.
///
/// Parameters for [`Client::e911_validate`] (wire method `e911Validate`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct E911ValidateParams {
    /// DID with e911 enabled / in process. (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub did: Option<String>,
    /// Full Name that will be validated. (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub full_name: Option<String>,
    /// Street Number that will be validated. (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub street_number: Option<u64>,
    /// Street Name that will be validated. (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub street_name: Option<String>,
    /// Address Type that will be validated (Values from e911AddressTypes).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub address_type: Option<String>,
    /// Address Number that will be validated.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub address_number: Option<u64>,
    /// City that will be validated. (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub city: Option<String>,
    /// State / Province that will be validated. (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub state: Option<String>,
    /// Country that will be validated. Value can be US (United states) or CA
    /// (Canada). (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub country: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub zip: Option<String>,
    /// Language that will be validated. Only available for addresses from
    /// Canada. Value can be EN (English) or FR (French).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub language: Option<String>,
    /// Additional Address Information that will be validated. Only available
    /// for addresses from Canada.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub other_info: Option<String>,
}

/// \- Retrieves a list of Allowed Codecs if no additional parameter is provided.
/// \- Retrieves a specific Allowed Codec if a codec code is provided.
///
/// Parameters for [`Client::get_allowed_codecs`] (wire method `getAllowedCodecs`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetAllowedCodecsParams {
    /// Code for a specific Codec (Example: 'ulaw')
    #[serde(skip_serializing_if = "Option::is_none")]
    pub codec: Option<String>,
}

/// \- Retrieves a list of Authentication Types if no additional parameter is
/// provided.
/// \- Retrieves a specific Authentication Type if an auth type code is provided.
///
/// Parameters for [`Client::get_auth_types`] (wire method `getAuthTypes`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetAuthTypesParams {
    /// Code for a specific Authorization Type (Example: 2)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub r#type: Option<String>,
}

/// \- Retrieves a list of backorder DIDs if no additional parameter is provided.
/// \- Retrieves a specific backorder DID if a backorder DID code is provided.
///
/// Parameters for [`Client::get_back_orders`] (wire method `getBackOrders`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetBackOrdersParams {
    /// ID for a specific backorder DID
    #[serde(skip_serializing_if = "Option::is_none")]
    pub id: Option<String>,
}

/// \- Retrieves Balance for your Account if no additional parameter is provided.
/// \- Retrieves Balance and Calls Statistics for your Account if "advanced"
/// parameter is true.
///
/// Parameters for [`Client::get_balance`] (wire method `getBalance`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetBalanceParams {
    /// True for Calls Statistics
    #[serde(
        skip_serializing_if = "Option::is_none",
        serialize_with = "crate::responses::serialize_opt_flag_01"
    )]
    pub advanced: Option<bool>,
}

/// \- Retrieves a list of Balance Management Options if no additional parameter
/// is provided.
/// \- Retrieves a specific Balance Management Option if a code is provided.
///
/// Parameters for [`Client::get_balance_management`] (wire method `getBalanceManagement`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetBalanceManagementParams {
    /// Code for a specific Balance Management Setting (Example: 1)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub balance_management: Option<String>,
}

/// \- Retrieves the Call Detail Records of all your calls.
///
/// Parameters for [`Client::get_cdr`] (wire method `getCDR`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetCDRParams {
    /// Start Date for Filtering CDR (Example: '2010-11-30') (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub date_from: Option<chrono::NaiveDate>,
    /// End Date for Filtering CDR (Example: '2010-11-30') (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub date_to: Option<chrono::NaiveDate>,
    /// Include Answered Calls to CDR (Boolean: 1/0)
    #[serde(
        skip_serializing_if = "Option::is_none",
        serialize_with = "crate::responses::serialize_opt_flag_01"
    )]
    pub answered: Option<bool>,
    /// Include NoAnswered calls to CDR (Boolean: 1/0)
    #[serde(
        skip_serializing_if = "Option::is_none",
        serialize_with = "crate::responses::serialize_opt_flag_01"
    )]
    pub noanswer: Option<bool>,
    /// Include Busy Calls to CDR (Boolean: 1/0)
    #[serde(
        skip_serializing_if = "Option::is_none",
        serialize_with = "crate::responses::serialize_opt_flag_01"
    )]
    pub busy: Option<bool>,
    /// Include Failed Calls to CDR (Boolean: 1/0)
    #[serde(
        skip_serializing_if = "Option::is_none",
        serialize_with = "crate::responses::serialize_opt_flag_01"
    )]
    pub failed: Option<bool>,
    /// IANA time zone for the reported timestamps (Example:
    /// 'America/New_York'); resolved to the numeric UTC offset VoIP.ms expects,
    /// at the query start date (DST-aware). Omit to keep timestamps in the
    /// account's configured time zone. (required)
    #[serde(
        skip_serializing_if = "Option::is_none",
        serialize_with = "crate::responses::serialize_opt_tz"
    )]
    pub timezone: Option<chrono_tz::Tz>,
    /// Filters CDR by Call Type (Values from getCallTypes)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub calltype: Option<String>,
    /// Filter CDR by Call Billing (Values from getCallBilling)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub callbilling: Option<String>,
    /// Filter CDR by Account (Values from getCallAccounts)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub account: Option<String>,
}

/// Wire form of [`GetCDRParams`]: `timezone` resolved to the numeric UTC
/// offset `getCDR` expects.
#[derive(Debug, Clone, Serialize)]
struct GetCDRParamsWire {
    #[serde(skip_serializing_if = "Option::is_none")]
    date_from: Option<chrono::NaiveDate>,
    #[serde(skip_serializing_if = "Option::is_none")]
    date_to: Option<chrono::NaiveDate>,
    #[serde(
        skip_serializing_if = "Option::is_none",
        serialize_with = "crate::responses::serialize_opt_flag_01"
    )]
    answered: Option<bool>,
    #[serde(
        skip_serializing_if = "Option::is_none",
        serialize_with = "crate::responses::serialize_opt_flag_01"
    )]
    noanswer: Option<bool>,
    #[serde(
        skip_serializing_if = "Option::is_none",
        serialize_with = "crate::responses::serialize_opt_flag_01"
    )]
    busy: Option<bool>,
    #[serde(
        skip_serializing_if = "Option::is_none",
        serialize_with = "crate::responses::serialize_opt_flag_01"
    )]
    failed: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    timezone: Option<crate::TimezoneOffset>,
    #[serde(skip_serializing_if = "Option::is_none")]
    calltype: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    callbilling: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    account: Option<String>,
}

impl TryFrom<&GetCDRParams> for GetCDRParamsWire {
    type Error = crate::types::TimezoneOffsetError;

    fn try_from(p: &GetCDRParams) -> std::result::Result<Self, Self::Error> {
        let timezone = match p.timezone {
            Some(tz) => {
                let start = p
                    .date_from
                    .ok_or(crate::types::TimezoneOffsetError::MissingStartDate)?;
                Some(crate::TimezoneOffset::at(tz, start)?)
            }
            None => None,
        };
        Ok(Self {
            date_from: p.date_from,
            date_to: p.date_to,
            answered: p.answered,
            noanswer: p.noanswer,
            busy: p.busy,
            failed: p.failed,
            timezone,
            calltype: p.calltype.clone(),
            callbilling: p.callbilling.clone(),
            account: p.account.clone(),
        })
    }
}

/// \- Retrieves all Sub Accounts if no additional parameter is provided.
/// \- Retrieves Reseller Client Accounts if Reseller Client ID is provided.
///
/// Parameters for [`Client::get_call_accounts`] (wire method `getCallAccounts`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetCallAccountsParams {}

/// \- Retrieves a list of Call Billing Options.
///
/// Parameters for [`Client::get_call_billing`] (wire method `getCallBilling`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetCallBillingParams {}

/// \- Retrieves a list of Call Huntings if no additional parameter is provided.
/// \- Retrieves a specific Call Huntings if a Call Hunting code is provided.
///
/// Parameters for [`Client::get_call_huntings`] (wire method `getCallHuntings`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetCallHuntingsParams {
    /// ID for a specific Call Hunting (Example: 323)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub callhunting: Option<u64>,
}

/// \- Retrieves all Call Parking entries if no additional parameter is provided.
/// \- Retrieves a specific Parking entry if a Call Parking ID is provided.
///
/// Parameters for [`Client::get_call_parking`] (wire method `getCallParking`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetCallParkingParams {
    /// ID for a specific Call Parking (Example: 737)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub callparking: Option<u64>,
}

/// \- Retrieves one especific call recording information, including the
/// recording file on mp3 format.
///
/// Parameters for [`Client::get_call_recording`] (wire method `getCallRecording`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetCallRecordingParams {
    /// Call Recording (Values from getCallRecordings) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub callrecording: Option<String>,
    /// Main Account or Sub Account related to the call recording (Values from
    /// getCallRecordings) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub account: Option<String>,
}

/// \- Retrieves all call recordings related to account.
///
/// Parameters for [`Client::get_call_recordings`] (wire method `getCallRecordings`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetCallRecordingsParams {
    /// Filter Call Recordings by Account (Values from getCallAccounts)
    /// (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub account: Option<String>,
    /// Number of records shown previously, used for pages
    #[serde(skip_serializing_if = "Option::is_none")]
    pub start: Option<u64>,
    /// Number of records to show
    #[serde(skip_serializing_if = "Option::is_none")]
    pub length: Option<u64>,
    /// Start Date for Filtering Call Recording (Example:'2018-11-01')
    /// (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub date_from: Option<chrono::NaiveDate>,
    /// End Date for Filtering Call Recording (Example:'2018-12-01') (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub date_to: Option<chrono::NaiveDate>,
}

/// \- Retrieves all Call Transcriptions if no additional parameter is provided.
///
/// Parameters for [`Client::get_call_transcriptions`] (wire method `getCallTranscriptions`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetCallTranscriptionsParams {
    /// Specific Account (Example: '100001_VoIP') (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub account: Option<String>,
    /// End Date for Filtering (Example: '2010-11-30') (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub date_to: Option<chrono::NaiveDate>,
    /// Start Date for Filtering (Example: '2010-11-30') (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub date_from: Option<chrono::NaiveDate>,
    /// Filters by Call Type (Values from getCallTypes)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub call_type: Option<String>,
}

/// \- Retrieves a list of Call Types and All DIDs if no additional parameter is
/// provided.
/// \- Retrieves a list of Call Types and Reseller Client DIDs if a Reseller
/// Client ID is provided.
///
/// Parameters for [`Client::get_call_types`] (wire method `getCallTypes`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetCallTypesParams {
    /// ID for a specific Reseller Client (Example: 561115)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub client: Option<String>,
}

/// \- Retrieves a list of Callbacks if no additional parameter is provided.
/// \- Retrieves a specific Callback if a Callback code is provided.
///
/// Parameters for [`Client::get_callbacks`] (wire method `getCallbacks`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetCallbacksParams {
    /// ID for a specific Callback (Example: 2359)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub callback: Option<String>,
}

/// \- Retrieves a list of CallerID Filterings if no additional parameter is
/// provided.
/// \- Retrieves a specific CallerID Filtering if a CallerID Filtering code is
/// provided.
///
/// Parameters for [`Client::get_caller_id_filtering`] (wire method `getCallerIDFiltering`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetCallerIDFilteringParams {
    /// ID for a specific CallerID Filtering (Example: 18915)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub filtering: Option<String>,
    /// DID for a specific CallerID Filtering (Example: 5551234567)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub did: Option<String>,
}

/// \- Retrieves a list of Carriers for Vanity Numbers if no additional parameter
/// is provided.
/// \- Retrieves a specific Carrier for Vanity Numbers if a carrier code is
/// provided.
///
/// Parameters for [`Client::get_carriers`] (wire method `getCarriers`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetCarriersParams {
    /// Code for a specific Carrier (Example: 2)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub carrier: Option<String>,
}

/// \- Retrieves Charges made to a specific Reseller Client.
///
/// Parameters for [`Client::get_charges`] (wire method `getCharges`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetChargesParams {
    /// ID for a specific Reseller Client (Example: 561115) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub client: Option<String>,
}

/// \- Retrieves a list of Packages for a specific Reseller Client.
///
/// Parameters for [`Client::get_client_packages`] (wire method `getClientPackages`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetClientPackagesParams {
    /// ID for a specific Reseller Client (Example: 561115) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub client: Option<String>,
}

/// \- Retrieves the Threshold Information for a specific Reseller Client.
///
/// Parameters for [`Client::get_client_threshold`] (wire method `getClientThreshold`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetClientThresholdParams {
    /// ID for a specific Reseller Client (Example: 561115) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub client: Option<String>,
}

/// \- Retrieves a list of all Clients if no additional parameter is provided.-
/// Retrieves a specific Reseller Client if a Reseller Client ID is provided.
/// \- Retrieves a specific Reseller Client if a Reseller Client e-mail is
/// provided.
///
/// Parameters for [`Client::get_clients`] (wire method `getClients`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetClientsParams {
    /// Parameter could have the following values: * Empty Value \[Not
    /// Required\] * Specific Reseller Client ID (Example: 561115) * Specific
    /// Reseller Client e-mail (Example: '\[email protected\]')
    #[serde(skip_serializing_if = "Option::is_none")]
    pub client: Option<String>,
}

/// \- Retrieves a list of Conferences if no additional parameter is provided.
/// \- Retrieves a specific Conference if a conference code is provided.
///
/// Parameters for [`Client::get_conference`] (wire method `getConference`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetConferenceParams {
    /// Code for a specific Conference (Example: 1599)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub conference: Option<u64>,
}

/// \- Retrieves a list of Member profiles if no additional parameter is
/// provided.
/// \- Retrieves a specific member if a member code is provided.
///
/// Parameters for [`Client::get_conference_members`] (wire method `getConferenceMembers`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetConferenceMembersParams {
    /// Code for a specific Member profile (Example: 1599)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub member: Option<u64>,
}

/// \- Retrieves a specific Recording File data in Base64 format.
///
/// Parameters for [`Client::get_conference_recording_file`] (wire method `getConferenceRecordingFile`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetConferenceRecordingFileParams {
    /// ID for a specific Conference (Example: 5356) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub conference: Option<u64>,
    /// ID for a specific Conference Recording (Example: 1543338379) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub recording: Option<u64>,
}

/// \- Retrieves a list of recordings of a specific conference.
///
/// Parameters for [`Client::get_conference_recordings`] (wire method `getConferenceRecordings`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetConferenceRecordingsParams {
    /// ID for a specific Conference (Example: 5356) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub conference: Option<u64>,
    /// Start Date for Filtering Transactions (Example: '2016-06-03')
    #[serde(skip_serializing_if = "Option::is_none")]
    pub date_from: Option<chrono::NaiveDate>,
    /// End Date for Filtering Transactions (Example: '2016-06-04')
    #[serde(skip_serializing_if = "Option::is_none")]
    pub date_to: Option<chrono::NaiveDate>,
}

/// \- Retrieves a list of Countries if no additional parameter is provided.
/// \- Retrieves a specific Country if a country code is provided.
///
/// Parameters for [`Client::get_countries`] (wire method `getCountries`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetCountriesParams {
    /// Code for a specific Country (Example: 'CA')
    #[serde(skip_serializing_if = "Option::is_none")]
    pub country: Option<String>,
}

/// \- Retrieves a list of Countries for International DIDs if no country code is
/// provided.
/// \- Retrieves a specific Country for International DIDs if a country code is
/// provided.
///
/// Parameters for [`Client::get_did_countries`] (wire method `getDIDCountries`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetDIDCountriesParams {
    /// ID for a specific country (Example: 205)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub country_id: Option<String>,
    /// Type of International DID (Values from getInternationalTypes) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub r#type: Option<String>,
}

/// \- Retrives a list of Canadian DIDs by Province and Ratecenter.
///
/// Parameters for [`Client::get_dids_can`] (wire method `getDIDsCAN`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetDIDsCANParams {
    /// Canadian Province (Values from getProvinces) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub province: Option<String>,
    /// Canadian Ratecenter (Values from getRateCentersCAN)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ratecenter: Option<String>,
}

/// \- Retrieves information from all your DIDs if no additional parameter is
/// provided.
/// \- Retrieves information from Reseller Client's DIDs if a Reseller Client ID
/// is provided.
/// \- Retrieves information from Sub Account's DIDs if a Sub Accunt is provided.
/// \- Retrieves information from a specific DID if a DID Number is provided.
/// \- Retrieves SMS information from a specific DID if the SMS is available.
///
/// Parameters for [`Client::get_dids_info`] (wire method `getDIDsInfo`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetDIDsInfoParams {
    /// Parameter could have the following values: * Empty Value \[Not
    /// Required\] * Specific Reseller Client ID (Example: 561115) * Specific
    /// Sub Account (Example: '100001_VoIP')
    #[serde(skip_serializing_if = "Option::is_none")]
    pub client: Option<String>,
    /// DID from Client or Sub Account (Example: 5551234567)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub did: Option<String>,
}

/// \- Retrieves a list of International Geographic DIDs by Country.
///
/// Parameters for [`Client::get_dids_international_geographic`] (wire method `getDIDsInternationalGeographic`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetDIDsInternationalGeographicParams {
    /// ID for a specific Country (Values from getDIDCountries) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub country_id: Option<String>,
}

/// \- Retrieves a list of International National DIDs by Country.
///
/// Parameters for [`Client::get_dids_international_national`] (wire method `getDIDsInternationalNational`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetDIDsInternationalNationalParams {
    /// ID for a specific Country (Values from getDIDCountries) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub country_id: Option<String>,
}

/// \- Retrieves a list of International TollFree DIDs by Country.
///
/// Parameters for [`Client::get_dids_international_toll_free`] (wire method `getDIDsInternationalTollFree`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetDIDsInternationalTollFreeParams {
    /// ID for a specific Country (Values from getDIDCountries) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub country_id: Option<String>,
}

/// \- Retrives a list of USA DIDs by State and Ratecenter.
///
/// Parameters for [`Client::get_dids_usa`] (wire method `getDIDsUSA`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetDIDsUSAParams {
    /// United States State (Values from getStates) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub state: Option<String>,
    /// United States Ratecenter (Values from getRateCentersUSA)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ratecenter: Option<String>,
}

/// \- Retrives the list of DIDs assigned to the VPRI.
///
/// Parameters for [`Client::get_did_vpri`] (wire method `getDIDvPRI`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetDIDvPRIParams {
    /// Id for specific Vpri (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub vpri: Option<String>,
}

/// \- Retrieves a list of DISAs if no additional parameter is provided.
/// \- Retrieves a specific DISA if a DISA code is provided.
///
/// Parameters for [`Client::get_disas`] (wire method `getDISAs`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetDISAsParams {
    /// ID for a specific DISA (Example: 2114)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub disa: Option<String>,
}

/// \- Retrieves a list of DTMF Modes if no additional parameter is provided.
/// \- Retrieves a specific DTMF Mode if a DTMF mode code is provided.
///
/// Parameters for [`Client::get_dtmf_modes`] (wire method `getDTMFModes`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetDTMFModesParams {
    /// Code for a specific DTMF Mode (Example: 'inband')
    #[serde(skip_serializing_if = "Option::is_none")]
    pub dtmf_mode: Option<DtmfMode>,
}

/// \- Retrieves Deposits made for a specific Reseller Client.
///
/// Parameters for [`Client::get_deposits`] (wire method `getDeposits`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetDepositsParams {
    /// ID for a specific Reseller Client (Example: 561115) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub client: Option<String>,
}

/// \- Retrieves a list of Device Types if no additional parameter is provided.
/// \- Retrieves a specific Device Type if a device type code is provided.
///
/// Parameters for [`Client::get_device_types`] (wire method `getDeviceTypes`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetDeviceTypesParams {
    /// Code for a specific Device Type (Example: 1)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub device_type: Option<String>,
}

/// \- Retrieves a list of "Email to Fax configurations" from your account if no
/// additional parameter is provided.
/// \- Retrieves a specific "Email to Fax configuration" from your account if a
/// ID is provided.
///
/// 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<u64>,
}

/// \- Retrieves a list of Fax Folders from your account.
///
/// 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<u64>,
}

/// \- Retrieves a Base64 code of the Fax Message to create a PDF file.
///
/// Parameters for [`Client::get_fax_message_pdf`] (wire method `getFaxMessagePDF`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetFAXMessagePDFParams {
    /// ID of the Fax Message requested (Values from getFaxMessages) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub id: Option<u64>,
}

/// \- Retrieves a list of Fax Messages.
/// \- Retrieves a specific Fax Message if a Fax Message ID is provided.
///
/// Parameters for [`Client::get_fax_messages`] (wire method `getFaxMessages`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetFAXMessagesParams {
    /// Start Date for Filtering Fax Messages (Example: '2014-03-30') - Default
    /// value: Today
    #[serde(skip_serializing_if = "Option::is_none")]
    pub from: Option<String>,
    /// End Date for Filtering Fax Messages (Example: '2014-03-30') - Default
    /// value: Today
    #[serde(skip_serializing_if = "Option::is_none")]
    pub to: Option<String>,
    /// Name of specific Fax Folder (Example: SENT) - Default value: ALL
    #[serde(skip_serializing_if = "Option::is_none")]
    pub folder: Option<String>,
    /// ID for a Specific Fax Message (Example: 23434)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub id: Option<u64>,
}

/// \- Retrieves a list of Fax Numbers.
///
/// Parameters for [`Client::get_fax_numbers_info`] (wire method `getFaxNumbersInfo`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetFAXNumbersInfoParams {
    /// Fax Number to retrieves the information of a single number, or not send
    /// if you want retrieves the information of all your Fax Numbers.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub did: Option<String>,
}

/// \- Shows if a Fax Number can be ported into our network
///
/// Parameters for [`Client::get_fax_numbers_portability`] (wire method `getFaxNumbersPortability`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetFAXNumbersPortabilityParams {
    /// DID Number to be ported into our network (Example: 5552341234)
    /// (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub did: Option<String>,
}

/// \- Retrieves a list of Canadian Fax Provinces if no additional parameter is
/// provided.
/// \- Retrieves a specific Canadian Fax Province if a province code is provided.
///
/// Parameters for [`Client::get_fax_provinces`] (wire method `getFaxProvinces`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetFAXProvincesParams {
    /// CODE for a specific Province (Example: AB)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub province: Option<String>,
}

/// \- Retrieves a list of Canadian Ratecenters by Province.
///
/// Parameters for [`Client::get_fax_rate_centers_can`] (wire method `getFaxRateCentersCAN`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetFAXRateCentersCANParams {
    /// Province two letters code (Example: AB) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub province: Option<String>,
}

/// \- Retrieves a list of USA Ratecenters by State.
///
/// Parameters for [`Client::get_fax_rate_centers_usa`] (wire method `getFaxRateCentersUSA`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetFAXRateCentersUSAParams {
    /// Province two letters code (Example: AL) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub state: Option<String>,
}

/// \- Retrieves a list of American Fax States if no additional parameter is
/// provided.
/// \- Retrieves a specific American Fax State if a state code is provided.
///
/// Parameters for [`Client::get_fax_states`] (wire method `getFaxStates`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetFAXStatesParams {
    /// CODE for a specific State (Example: AL)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub state: Option<String>,
}

/// \- Retrieves a list of Forwardings if no additional parameter is provided.
/// \- Retrieves a specific Forwarding if a fwd code is provided.
///
/// Parameters for [`Client::get_forwardings`] (wire method `getForwardings`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetForwardingsParams {
    /// ID for a specific Forwarding (Example: 18635)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub forwarding: Option<String>,
}

/// \- Shows the IP used by the client application requesting information from
/// the API
/// \* this is the only function not using the IP for authentication.
/// \* the IP returned should be the one used in the API Configuration.
///
/// Parameters for [`Client::get_ip`] (wire method `getIP`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetIPParams {}

/// \- Retrieves a list of IVRs if no additional parameter is provided.
/// \- Retrieves a specific IVR if a IVR code is provided.
///
/// Parameters for [`Client::get_ivrs`] (wire method `getIVRs`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetIVRsParams {
    /// ID for a specific IVR (Example: 4636)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ivr: Option<String>,
}

/// \- Retrieves a list of Types for International DIDs if no additional
/// parameter is provided.
/// \- Retrieves a specific Types for International DIDs if a type code is
/// provided.
///
/// Parameters for [`Client::get_international_types`] (wire method `getInternationalTypes`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetInternationalTypesParams {
    /// Code for a specific International Type (Example: 'NATIONAL')
    #[serde(skip_serializing_if = "Option::is_none")]
    pub r#type: Option<String>,
}

/// \- Retrieves a list of 'JoinWhenEmpty' Types if no additional parameter is
/// provided.
/// \- Retrieves a specific 'JoinWhenEmpty' Types if a type code is provided.
///
/// Parameters for [`Client::get_join_when_empty_types`] (wire method `getJoinWhenEmptyTypes`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetJoinWhenEmptyTypesParams {
    /// Code for a specific 'JoinWhenEmpty' Type (Example: 'yes')
    #[serde(skip_serializing_if = "Option::is_none")]
    pub r#type: Option<String>,
}

/// \- Retrieve the details of an attached invoice.
///
/// Parameters for [`Client::get_lnp_attach`] (wire method `getLNPAttach`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetLNPAttachParams {
    /// ID of the invoice (attachment) previously uploaded. (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub attachid: Option<u64>,
}

/// \- Retrieve the list of invoice (attached) files from a given portability
/// process.
///
/// Parameters for [`Client::get_lnp_attach_list`] (wire method `getLNPAttachList`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetLNPAttachListParams {
    /// ID of the port previously created. (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub portid: Option<u64>,
}

/// \- Retrieve the details of a given portability process.
///
/// Parameters for [`Client::get_lnp_details`] (wire method `getLNPDetails`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetLNPDetailsParams {
    /// ID of the port previously created. (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub portid: Option<u64>,
}

/// \- Retrieve the full list of all your portability processes.
///
/// Parameters for [`Client::get_lnp_list`] (wire method `getLNPList`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetLNPListParams {
    /// ID of the port previously created. (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub portid: Option<u64>,
    /// Status code to filtering Ports. Example: precessing. (You can use the
    /// values returned by the method getLNPListStatus)
    #[serde(skip_serializing_if = "Option::is_none", rename = "portStatus")]
    pub port_status: Option<String>,
    /// Start Date for filtering Ports. (Example: '2014-03-30')
    #[serde(skip_serializing_if = "Option::is_none", rename = "startDate")]
    pub start_date: Option<String>,
    /// End Date for filtering Ports. (Example: '2014-03-30')
    #[serde(skip_serializing_if = "Option::is_none", rename = "endDate")]
    pub end_date: Option<String>,
}

/// \- Retrieve the list of possible status of a portability process.
///
/// Parameters for [`Client::get_lnp_list_status`] (wire method `getLNPListStatus`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetLNPListStatusParams {}

/// \- Retrieve the list of notes from the given portability process.
///
/// Parameters for [`Client::get_lnp_notes`] (wire method `getLNPNotes`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetLNPNotesParams {
    /// ID of the port previously created. (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub portid: Option<u64>,
}

/// \- Retrieve the current status of a given portability process.
///
/// Parameters for [`Client::get_lnp_status`] (wire method `getLNPStatus`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetLNPStatusParams {
    /// ID of the port previously created. (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub portid: Option<u64>,
}

/// \- Retrieves a list of Languages if no additional parameter is provided.
/// \- Retrieves a specific Language if a language code is provided.
///
/// Parameters for [`Client::get_languages`] (wire method `getLanguages`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetLanguagesParams {
    /// Code for a specific Language (Example: 'en')
    #[serde(skip_serializing_if = "Option::is_none")]
    pub language: Option<String>,
}

/// \- Retrieves a list of locale codes if no additional parameter is provided.
/// \- Retrieves a specific locale code if a language code is provided.
///
/// Parameters for [`Client::get_locales`] (wire method `getLocales`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetLocalesParams {
    /// Code for a specific Locale Code (Example: 'en-US')
    #[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 {}

/// \- Retrieves a list of Lock Modes if no additional parameter is provided.
/// \- Retrieves a specific Lock Mode if a lock code is provided.
///
/// Parameters for [`Client::get_lock_international`] (wire method `getLockInternational`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetLockInternationalParams {
    /// Code for a specific Lock International Mode (Example: 1)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lock_international: Option<String>,
}

/// \- Retrieves a list of MMS messages by: date range, mms type, DID number, and
/// contact.
///
/// Parameters for [`Client::get_mms`] (wire method `getMMS`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetMMSParams {
    /// ID for a specific MMS (Example: 1918)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub mms: Option<u64>,
    /// Start Date for Filtering MMSs (Example: '2014-03-30') - Default value:
    /// Today
    #[serde(skip_serializing_if = "Option::is_none")]
    pub from: Option<String>,
    /// End Date for Filtering MMSs (Example: '2014-03-30') - Default value:
    /// Today
    #[serde(skip_serializing_if = "Option::is_none")]
    pub to: Option<String>,
    /// Filter MMSs by Type (Boolean: 1 = received / 0 = sent)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub r#type: Option<MessageType>,
    /// DID number for Filtering MMSs (Example: 5551234567)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub did: Option<String>,
    /// Contact number for Filtering MMSs (Example: 5551234567)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub contact: Option<String>,
    /// Number of records to be displayed (Example: 20) - Default value: 50
    #[serde(skip_serializing_if = "Option::is_none")]
    pub limit: Option<String>,
    /// IANA time zone for the reported timestamps (Example:
    /// 'America/New_York'); resolved to the numeric UTC offset VoIP.ms expects,
    /// at the query start date (DST-aware). Omit to keep timestamps in the
    /// account's configured time zone.
    #[serde(
        skip_serializing_if = "Option::is_none",
        serialize_with = "crate::responses::serialize_opt_tz"
    )]
    pub timezone: Option<chrono_tz::Tz>,
    /// Filter to recive all MMSs and SMSs, 1 recive all SMS and MMS, 0 if only
    /// need MMS, important: the sms ID must be 0
    #[serde(skip_serializing_if = "Option::is_none")]
    pub all_messages: Option<u64>,
}

/// Wire form of [`GetMMSParams`]: `timezone` resolved to the numeric UTC
/// offset `getMMS` expects.
#[derive(Debug, Clone, Serialize)]
struct GetMMSParamsWire {
    #[serde(skip_serializing_if = "Option::is_none")]
    mms: Option<u64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    from: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    to: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    r#type: Option<MessageType>,
    #[serde(skip_serializing_if = "Option::is_none")]
    did: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    contact: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    limit: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    timezone: Option<crate::TimezoneOffset>,
    #[serde(skip_serializing_if = "Option::is_none")]
    all_messages: Option<u64>,
}

impl TryFrom<&GetMMSParams> for GetMMSParamsWire {
    type Error = crate::types::TimezoneOffsetError;

    fn try_from(p: &GetMMSParams) -> std::result::Result<Self, Self::Error> {
        let timezone = match p.timezone {
            Some(tz) => {
                let start = p
                    .from
                    .as_deref()
                    .ok_or(crate::types::TimezoneOffsetError::MissingStartDate)?
                    .trim()
                    .parse::<chrono::NaiveDate>()
                    .map_err(|_| crate::types::TimezoneOffsetError::InvalidStartDate)?;
                Some(crate::TimezoneOffset::at(tz, start)?)
            }
            None => None,
        };
        Ok(Self {
            mms: p.mms,
            from: p.from.clone(),
            to: p.to.clone(),
            r#type: p.r#type.clone(),
            did: p.did.clone(),
            contact: p.contact.clone(),
            limit: p.limit.clone(),
            timezone,
            all_messages: p.all_messages,
        })
    }
}

/// \- Retrieves media files from the message.
///
/// Parameters for [`Client::get_media_mms`] (wire method `getMediaMMS`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetMediaMMSParams {
    /// ID for a specific MMS (Example: 1918)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub id: Option<u64>,
    /// Return the list of media attachments as an Array if the value is 1 or as
    /// a JSON Object if the value is 0 (Default: 0)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub media_as_array: Option<u64>,
}

/// \- Retrieves a list of Music on Hold Options if no additional parameter is
/// provided.
/// \- Retrieves a specific Music on Hold Option if a MOH code is provided.
///
/// Parameters for [`Client::get_music_on_hold`] (wire method `getMusicOnHold`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetMusicOnHoldParams {
    /// Code for a specific Music on Hold (Example: 'jazz')
    #[serde(skip_serializing_if = "Option::is_none")]
    pub music_on_hold: Option<String>,
}

/// \- Retrieves a list of NAT Options if no additional parameter is provided.
/// \- Retrieves a specific NAT Option if a NAT code is provided.
///
/// Parameters for [`Client::get_nat`] (wire method `getNAT`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetNATParams {
    /// Code for a specific NAT Option (Example: 'route')
    #[serde(skip_serializing_if = "Option::is_none")]
    pub nat: Option<Nat>,
}

/// \- Retrieves a list of Packages if no additional parameter is provided.-
/// Retrieves a specific Package if a package code is provided.
///
/// Parameters for [`Client::get_packages`] (wire method `getPackages`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetPackagesParams {
    /// Code for a specific Package (Example: 8378)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub package: Option<String>,
}

/// \- Retrieves a list of Phonebook entries if no additional parameter is
/// provided.
/// \- Retrieves a list of Phonebook entries if a name is provided.
/// \- Retrieves a specific Phonebook entry if a Phonebook code is provided.
/// \- Retrieves a list of Phonebook entries if a phonebook group name is
/// provided.
/// \- Retrieves a list of Phonebook entries if a phonebook group code is
/// provided.
///
/// Parameters for [`Client::get_phonebook`] (wire method `getPhonebook`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetPhonebookParams {
    /// ID for a specific Phonebook entry (Example: 32207)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub phonebook: Option<String>,
    /// Name to be searched in database (Example: 'jane')
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    /// ID for a specific Phonebook group
    #[serde(skip_serializing_if = "Option::is_none")]
    pub group: Option<String>,
    /// Group Name
    #[serde(skip_serializing_if = "Option::is_none")]
    pub group_name: Option<String>,
}

/// \- Retrieves a list of Phonebook groups if no additional parameter is
/// provided.
/// \- Retrieves a list of Phonebook groups if a name is provided.
/// \- Retrieves a specific Phonebook group if a group ID is provided.
///
/// Parameters for [`Client::get_phonebook_groups`] (wire method `getPhonebookGroups`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetPhonebookGroupsParams {
    /// Group Name
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    /// ID for a specific Phonebook group
    #[serde(skip_serializing_if = "Option::is_none")]
    pub group: Option<String>,
}

/// \- Retrieves a list of Play Instructions modes if no additional parameter is
/// provided.
/// \- Retrieves a specific Play Instructions mode if a play code is provided.
///
/// Parameters for [`Client::get_play_instructions`] (wire method `getPlayInstructions`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetPlayInstructionsParams {
    /// Code for a specific Play Instructions setting (Example: 'u')
    #[serde(skip_serializing_if = "Option::is_none")]
    pub play_instructions: Option<PlayInstructions>,
}

/// \- Shows if a DID Number can be ported into our network.
/// \- Display plans and rates available if the DID Number can be ported into our
/// network.
///
/// Parameters for [`Client::get_portability`] (wire method `getPortability`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetPortabilityParams {
    /// DID Number to be ported into our network (Example: 5552341234)
    /// (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub did: Option<String>,
}

/// \- Retrieves a list of Protocols if no additional parameter is provided.
/// \- Retrieves a specific Protocol if a protocol code is provided.
///
/// Parameters for [`Client::get_protocols`] (wire method `getProtocols`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetProtocolsParams {
    /// Code for a specific Protocol (Example: 3)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub protocol: Option<String>,
}

/// \- Retrieves a list of Canadian Provinces.
///
/// Parameters for [`Client::get_provinces`] (wire method `getProvinces`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetProvincesParams {}

/// \- Retrieves a list of Queue entries if no additional parameter is provided.
/// \- Retrieves a specific Queue entry if a Queue code is provided.
///
/// Parameters for [`Client::get_queues`] (wire method `getQueues`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetQueuesParams {
    /// ID for a specific Queue (Example: 4764)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub queue: Option<String>,
}

/// \- Retrieves a list of Canadian Ratecenters by Province.
///
/// Parameters for [`Client::get_rate_centers_can`] (wire method `getRateCentersCAN`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetRateCentersCANParams {
    /// Canadian Province (Values from getProvinces) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub province: Option<String>,
}

/// \- Retrieves a list of USA Ratecenters by State.
///
/// Parameters for [`Client::get_rate_centers_usa`] (wire method `getRateCentersUSA`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetRateCentersUSAParams {
    /// United States State (Values from getStates) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub state: Option<String>,
}

/// \- Retrieves the Rates for a specific Package and a Search term.
///
/// Parameters for [`Client::get_rates`] (wire method `getRates`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetRatesParams {
    /// ID for a specific Package (Example: 92364) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub package: Option<String>,
    /// Query for searching rates (Example: 'Canada') (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub query: Option<String>,
}

/// \- Retrieves a specific Recording File data in Base64 format.
///
/// Parameters for [`Client::get_recording_file`] (wire method `getRecordingFile`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetRecordingFileParams {
    /// ID for a specific Recording (Example: 7567) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub recording: Option<String>,
}

/// \- Retrieves a list of Recordings if no additional parameter is provided.
/// \- Retrieves a specific Recording if a Recording code is provided.
///
/// Parameters for [`Client::get_recordings`] (wire method `getRecordings`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetRecordingsParams {
    /// ID for a specific Recording (Example: 7567)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub recording: Option<String>,
}

/// \- Retrieves the Registration Status of all accounts if no account is
/// provided.
///
/// Parameters for [`Client::get_registration_status`] (wire method `getRegistrationStatus`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetRegistrationStatusParams {
    /// Specific Account (Example: '100001_VoIP') (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub account: Option<String>,
}

/// \- Retrieves a list of 'ReportEstimateHoldTime' Types if no additional
/// parameter is provided.
/// \- Retrieves a specific 'ReportEstimateHoldTime' Type if a type code is
/// provided.
///
/// Parameters for [`Client::get_report_estimated_hold_time`] (wire method `getReportEstimatedHoldTime`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetReportEstimatedHoldTimeParams {
    /// Code for a specific 'ReportEstimatedHoldTime' Type (Example: 'yes')
    #[serde(skip_serializing_if = "Option::is_none")]
    pub r#type: Option<String>,
}

/// \- Retrieves Balance and Calls Statistics for a specific Reseller Client for
/// the last 30 days and current day.
///
/// Parameters for [`Client::get_reseller_balance`] (wire method `getResellerBalance`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetResellerBalanceParams {
    /// ID for a specific Reseller Client (Example: 561115) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub client: Option<String>,
}

/// \- Retrieves the Call Detail Records for a specific Reseller Client.
///
/// Parameters for [`Client::get_reseller_cdr`] (wire method `getResellerCDR`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetResellerCDRParams {
    /// Start Date for Filtering CDR (Example: '2010-11-30') (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub date_from: Option<chrono::NaiveDate>,
    /// End Date for Filtering CDR (Example: '2010-11-30') (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub date_to: Option<chrono::NaiveDate>,
    /// ID for a specific Reseller Client (Example: 561115) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub client: Option<u64>,
    /// Include Answered Calls to CDR (Boolean: 1/0)
    #[serde(
        skip_serializing_if = "Option::is_none",
        serialize_with = "crate::responses::serialize_opt_flag_01"
    )]
    pub answered: Option<bool>,
    /// Include NoAnswered calls to CDR (Boolean: 1/0)
    #[serde(
        skip_serializing_if = "Option::is_none",
        serialize_with = "crate::responses::serialize_opt_flag_01"
    )]
    pub noanswer: Option<bool>,
    /// Include Busy Calls to CDR (Boolean: 1/0)
    #[serde(
        skip_serializing_if = "Option::is_none",
        serialize_with = "crate::responses::serialize_opt_flag_01"
    )]
    pub busy: Option<bool>,
    /// Include Failed Calls to CDR (Boolean: 1/0)
    #[serde(
        skip_serializing_if = "Option::is_none",
        serialize_with = "crate::responses::serialize_opt_flag_01"
    )]
    pub failed: Option<bool>,
    /// IANA time zone for the reported timestamps (Example:
    /// 'America/New_York'); resolved to the numeric UTC offset VoIP.ms expects,
    /// at the query start date (DST-aware). Omit to keep timestamps in the
    /// account's configured time zone. (required)
    #[serde(
        skip_serializing_if = "Option::is_none",
        serialize_with = "crate::responses::serialize_opt_tz"
    )]
    pub timezone: Option<chrono_tz::Tz>,
    /// Filters CDR by Call Type (Values from getCallTypes)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub calltype: Option<String>,
    /// Filter CDR by Call Billing (Values from getCallBilling)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub callbilling: Option<String>,
    /// Filter CDR by Account (Values from getCallAccounts)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub account: Option<String>,
}

/// Wire form of [`GetResellerCDRParams`]: `timezone` resolved to the numeric UTC
/// offset `getResellerCDR` expects.
#[derive(Debug, Clone, Serialize)]
struct GetResellerCDRParamsWire {
    #[serde(skip_serializing_if = "Option::is_none")]
    date_from: Option<chrono::NaiveDate>,
    #[serde(skip_serializing_if = "Option::is_none")]
    date_to: Option<chrono::NaiveDate>,
    #[serde(skip_serializing_if = "Option::is_none")]
    client: Option<u64>,
    #[serde(
        skip_serializing_if = "Option::is_none",
        serialize_with = "crate::responses::serialize_opt_flag_01"
    )]
    answered: Option<bool>,
    #[serde(
        skip_serializing_if = "Option::is_none",
        serialize_with = "crate::responses::serialize_opt_flag_01"
    )]
    noanswer: Option<bool>,
    #[serde(
        skip_serializing_if = "Option::is_none",
        serialize_with = "crate::responses::serialize_opt_flag_01"
    )]
    busy: Option<bool>,
    #[serde(
        skip_serializing_if = "Option::is_none",
        serialize_with = "crate::responses::serialize_opt_flag_01"
    )]
    failed: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    timezone: Option<crate::TimezoneOffset>,
    #[serde(skip_serializing_if = "Option::is_none")]
    calltype: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    callbilling: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    account: Option<String>,
}

impl TryFrom<&GetResellerCDRParams> for GetResellerCDRParamsWire {
    type Error = crate::types::TimezoneOffsetError;

    fn try_from(p: &GetResellerCDRParams) -> std::result::Result<Self, Self::Error> {
        let timezone = match p.timezone {
            Some(tz) => {
                let start = p
                    .date_from
                    .ok_or(crate::types::TimezoneOffsetError::MissingStartDate)?;
                Some(crate::TimezoneOffset::at(tz, start)?)
            }
            None => None,
        };
        Ok(Self {
            date_from: p.date_from,
            date_to: p.date_to,
            client: p.client,
            answered: p.answered,
            noanswer: p.noanswer,
            busy: p.busy,
            failed: p.failed,
            timezone,
            calltype: p.calltype.clone(),
            callbilling: p.callbilling.clone(),
            account: p.account.clone(),
        })
    }
}

/// \- Retrieves a list of MMS messages for a specific Reseller Client. by: date
/// range, mms type, DID number, and contact
///
/// 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<u64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub client: Option<u64>,
    /// Start Date for Filtering SMSs (Example: '2014-03-30') - Default value:
    /// Today
    #[serde(skip_serializing_if = "Option::is_none")]
    pub from: Option<String>,
    /// End Date for Filtering MMSs (Example: '2014-03-30') - Default value:
    /// Todayclient => \[Required\] ID for a specific Reseller Client (Example:
    /// 561115)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub to: Option<String>,
    /// Filter SMSs by Type (Boolean: 1 = received / 0 = sent)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub r#type: Option<MessageType>,
    /// DID number for Filtering MMSs (Example: 5551234567)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub did: Option<String>,
    /// Contact number for Filtering MMSs (Example: 5551234567)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub contact: Option<String>,
    /// Number of records to be displayed (Example: 20) - Default value: 50
    #[serde(skip_serializing_if = "Option::is_none")]
    pub limit: Option<String>,
    /// IANA time zone for the reported timestamps (Example:
    /// 'America/New_York'); resolved to the numeric UTC offset VoIP.ms expects,
    /// at the query start date (DST-aware). Omit to keep timestamps in the
    /// account's configured time zone.
    #[serde(
        skip_serializing_if = "Option::is_none",
        serialize_with = "crate::responses::serialize_opt_tz"
    )]
    pub timezone: Option<chrono_tz::Tz>,
    /// Filter to recive all SMSs and MMSs, 1 recive all SMS and MMS, 0 if only
    /// need SMS, important: the sms ID must be 0
    #[serde(skip_serializing_if = "Option::is_none")]
    pub all_messages: Option<u64>,
}

/// Wire form of [`GetResellerMMSParams`]: `timezone` resolved to the numeric UTC
/// offset `getResellerMMS` expects.
#[derive(Debug, Clone, Serialize)]
struct GetResellerMMSParamsWire {
    #[serde(skip_serializing_if = "Option::is_none")]
    mms: Option<u64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    client: Option<u64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    from: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    to: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    r#type: Option<MessageType>,
    #[serde(skip_serializing_if = "Option::is_none")]
    did: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    contact: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    limit: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    timezone: Option<crate::TimezoneOffset>,
    #[serde(skip_serializing_if = "Option::is_none")]
    all_messages: Option<u64>,
}

impl TryFrom<&GetResellerMMSParams> for GetResellerMMSParamsWire {
    type Error = crate::types::TimezoneOffsetError;

    fn try_from(p: &GetResellerMMSParams) -> std::result::Result<Self, Self::Error> {
        let timezone = match p.timezone {
            Some(tz) => {
                let start = p
                    .from
                    .as_deref()
                    .ok_or(crate::types::TimezoneOffsetError::MissingStartDate)?
                    .trim()
                    .parse::<chrono::NaiveDate>()
                    .map_err(|_| crate::types::TimezoneOffsetError::InvalidStartDate)?;
                Some(crate::TimezoneOffset::at(tz, start)?)
            }
            None => None,
        };
        Ok(Self {
            mms: p.mms,
            client: p.client,
            from: p.from.clone(),
            to: p.to.clone(),
            r#type: p.r#type.clone(),
            did: p.did.clone(),
            contact: p.contact.clone(),
            limit: p.limit.clone(),
            timezone,
            all_messages: p.all_messages,
        })
    }
}

/// \- Retrieves a list of SMS messages for a specific Reseller Client. by: date
/// range, sms type, DID number, and contact
///
/// Parameters for [`Client::get_reseller_sms`] (wire method `getResellerSMS`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetResellerSMSParams {
    /// ID for a specific SMS (Example: 5853)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sms: Option<u64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub client: Option<u64>,
    /// Start Date for Filtering SMSs (Example: '2014-03-30') - Default value:
    /// Today
    #[serde(skip_serializing_if = "Option::is_none")]
    pub from: Option<String>,
    /// End Date for Filtering SMSs (Example: '2014-03-30') - Default value:
    /// Todayclient => \[Required\] ID for a specific Reseller Client (Example:
    /// 561115)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub to: Option<String>,
    /// Filter SMSs by Type (Boolean: 1 = received / 0 = sent)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub r#type: Option<MessageType>,
    /// DID number for Filtering SMSs (Example: 5551234567)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub did: Option<String>,
    /// Contact number for Filtering SMSs (Example: 5551234567)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub contact: Option<String>,
    /// Number of records to be displayed (Example: 20) - Default value: 50
    #[serde(skip_serializing_if = "Option::is_none")]
    pub limit: Option<String>,
    /// IANA time zone for the reported timestamps (Example:
    /// 'America/New_York'); resolved to the numeric UTC offset VoIP.ms expects,
    /// at the query start date (DST-aware). Omit to keep timestamps in the
    /// account's configured time zone.
    #[serde(
        skip_serializing_if = "Option::is_none",
        serialize_with = "crate::responses::serialize_opt_tz"
    )]
    pub timezone: Option<chrono_tz::Tz>,
    /// Filter to recive all SMSs and MMSs, 1 recive all SMS and MMS, 0 if only
    /// need SMS, important: the sms ID must be 0
    #[serde(skip_serializing_if = "Option::is_none")]
    pub all_messages: Option<u64>,
}

/// Wire form of [`GetResellerSMSParams`]: `timezone` resolved to the numeric UTC
/// offset `getResellerSMS` expects.
#[derive(Debug, Clone, Serialize)]
struct GetResellerSMSParamsWire {
    #[serde(skip_serializing_if = "Option::is_none")]
    sms: Option<u64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    client: Option<u64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    from: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    to: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    r#type: Option<MessageType>,
    #[serde(skip_serializing_if = "Option::is_none")]
    did: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    contact: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    limit: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    timezone: Option<crate::TimezoneOffset>,
    #[serde(skip_serializing_if = "Option::is_none")]
    all_messages: Option<u64>,
}

impl TryFrom<&GetResellerSMSParams> for GetResellerSMSParamsWire {
    type Error = crate::types::TimezoneOffsetError;

    fn try_from(p: &GetResellerSMSParams) -> std::result::Result<Self, Self::Error> {
        let timezone = match p.timezone {
            Some(tz) => {
                let start = p
                    .from
                    .as_deref()
                    .ok_or(crate::types::TimezoneOffsetError::MissingStartDate)?
                    .trim()
                    .parse::<chrono::NaiveDate>()
                    .map_err(|_| crate::types::TimezoneOffsetError::InvalidStartDate)?;
                Some(crate::TimezoneOffset::at(tz, start)?)
            }
            None => None,
        };
        Ok(Self {
            sms: p.sms,
            client: p.client,
            from: p.from.clone(),
            to: p.to.clone(),
            r#type: p.r#type.clone(),
            did: p.did.clone(),
            contact: p.contact.clone(),
            limit: p.limit.clone(),
            timezone,
            all_messages: p.all_messages,
        })
    }
}

/// \- Retrieves a list of Ring Groups if no additional parameter is provided.
/// \- Retrieves a specific Ring Group if a ring group code is provided.
///
/// Parameters for [`Client::get_ring_groups`] (wire method `getRingGroups`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetRingGroupsParams {
    /// ID for a specific Ring Group (Example: 4768)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ring_group: Option<String>,
}

/// \- Retrieves a list of Ring Strategies if no additional parameter is
/// provided.
/// \- Retrieves a specific Ring Strategy if a ring strategy code is provided.
///
/// Parameters for [`Client::get_ring_strategies`] (wire method `getRingStrategies`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetRingStrategiesParams {
    /// ID for a specific Ring Strategy (Example: 'rrmemory')
    #[serde(skip_serializing_if = "Option::is_none")]
    pub strategy: Option<String>,
}

/// \- Retrieves a list of Route Options if no additional parameter is provided.
/// \- Retrieves a specific Route Option if a route code is provided.
///
/// Parameters for [`Client::get_routes`] (wire method `getRoutes`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetRoutesParams {
    /// Code for a specific Route (Example: 2)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub route: Option<String>,
}

/// \- Retrieves a list of SIP URIs if no additional parameter is provided.
/// \- Retrieves a specific SIP URI if a SIP URI code is provided.
///
/// Parameters for [`Client::get_sip_uris`] (wire method `getSIPURIs`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetSIPURIsParams {
    /// ID for a specific SIP URI (Example: 6199)
    #[serde(skip_serializing_if = "Option::is_none", rename = "sipuri")]
    pub sip_uri: Option<String>,
}

/// \- Retrieves a list of SMS messages by: date range, sms type, DID number, and
/// contact.
///
/// Parameters for [`Client::get_sms`] (wire method `getSMS`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetSMSParams {
    /// ID for a specific SMS (Example: 5853)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sms: Option<u64>,
    /// Start Date for Filtering SMSs (Example: '2014-03-30') - Default value:
    /// Today
    #[serde(skip_serializing_if = "Option::is_none")]
    pub from: Option<String>,
    /// End Date for Filtering SMSs (Example: '2014-03-30') - Default value:
    /// Today
    #[serde(skip_serializing_if = "Option::is_none")]
    pub to: Option<String>,
    /// Filter SMSs by Type (Boolean: 1 = received / 0 = sent)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub r#type: Option<MessageType>,
    /// DID number for Filtering SMSs (Example: 5551234567)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub did: Option<String>,
    /// Contact number for Filtering SMSs (Example: 5551234567)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub contact: Option<String>,
    /// Number of records to be displayed (Example: 20) - Default value: 50
    #[serde(skip_serializing_if = "Option::is_none")]
    pub limit: Option<String>,
    /// IANA time zone for the reported timestamps (Example:
    /// 'America/New_York'); resolved to the numeric UTC offset VoIP.ms expects,
    /// at the query start date (DST-aware). Omit to keep timestamps in the
    /// account's configured time zone.
    #[serde(
        skip_serializing_if = "Option::is_none",
        serialize_with = "crate::responses::serialize_opt_tz"
    )]
    pub timezone: Option<chrono_tz::Tz>,
    /// Filter to recive all SMSs and MMSs, 1 recive all SMS and MMS, 0 if only
    /// need SMS, important: the sms ID must be 0
    #[serde(skip_serializing_if = "Option::is_none")]
    pub all_messages: Option<u64>,
}

/// Wire form of [`GetSMSParams`]: `timezone` resolved to the numeric UTC
/// offset `getSMS` expects.
#[derive(Debug, Clone, Serialize)]
struct GetSMSParamsWire {
    #[serde(skip_serializing_if = "Option::is_none")]
    sms: Option<u64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    from: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    to: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    r#type: Option<MessageType>,
    #[serde(skip_serializing_if = "Option::is_none")]
    did: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    contact: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    limit: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    timezone: Option<crate::TimezoneOffset>,
    #[serde(skip_serializing_if = "Option::is_none")]
    all_messages: Option<u64>,
}

impl TryFrom<&GetSMSParams> for GetSMSParamsWire {
    type Error = crate::types::TimezoneOffsetError;

    fn try_from(p: &GetSMSParams) -> std::result::Result<Self, Self::Error> {
        let timezone = match p.timezone {
            Some(tz) => {
                let start = p
                    .from
                    .as_deref()
                    .ok_or(crate::types::TimezoneOffsetError::MissingStartDate)?
                    .trim()
                    .parse::<chrono::NaiveDate>()
                    .map_err(|_| crate::types::TimezoneOffsetError::InvalidStartDate)?;
                Some(crate::TimezoneOffset::at(tz, start)?)
            }
            None => None,
        };
        Ok(Self {
            sms: p.sms,
            from: p.from.clone(),
            to: p.to.clone(),
            r#type: p.r#type.clone(),
            did: p.did.clone(),
            contact: p.contact.clone(),
            limit: p.limit.clone(),
            timezone,
            all_messages: p.all_messages,
        })
    }
}

/// \- Retrieves a list of Servers with their info if no additional parameter is
/// provided.
/// \- Retrieves a specific Server with its info if a Server POP is provided.
///
/// Parameters for [`Client::get_servers_info`] (wire method `getServersInfo`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetServersInfoParams {
    /// POP for a specific Server (Example: 1)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub server_pop: Option<String>,
}

/// \- Retrieves a list of USA States.
///
/// Parameters for [`Client::get_states`] (wire method `getStates`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetStatesParams {}

/// \- Retrieves a list of Static Members from a queue if no additional parameter
/// is provided.
/// \- Retrieves a specific Static Member from a queue if Queue ID and Member ID
/// are provided
///
/// Parameters for [`Client::get_static_members`] (wire method `getStaticMembers`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetStaticMembersParams {
    /// ID for a specific Queue (Example: 4136) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub queue: Option<String>,
    /// ID for a specific Static Member (Example: 163) - The Member must belong
    /// to the queue provided
    #[serde(skip_serializing_if = "Option::is_none")]
    pub member: Option<String>,
}

/// \- Retrieves all Sub Accounts if no additional parameter is provided.
/// \- Retrieves Reseller Client Accounts if Reseller Client ID is provided.
/// \- Retrieves a specific Sub Account if a Sub Account is provided.
///
/// Parameters for [`Client::get_sub_accounts`] (wire method `getSubAccounts`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetSubAccountsParams {
    /// Parameter could have the following values: * Empty Value \[Not
    /// Required\] * Specific Sub Account (Example: '100000_VoIP') * Specific
    /// Reseller Client ID (Example: 561115)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub account: Option<String>,
}

/// \- Retrieves the Rates for a specific Route (Premium, Value) and a Search
/// term.
///
/// Parameters for [`Client::get_termination_rates`] (wire method `getTerminationRates`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetTerminationRatesParams {
    /// Query for searching rates (Example: 'Canada') (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub query: Option<String>,
    /// Route Code (Values from getRoutes)(Example: '2') (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub route: Option<u64>,
}

/// \- Retrieves a list of Time Conditions if no additional parameter is
/// provided.
/// \- Retrieves a specific Time Condition if a time condition code is provided.
///
/// Parameters for [`Client::get_time_conditions`] (wire method `getTimeConditions`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetTimeConditionsParams {
    /// ID for a specific Time Condition (Example: 1830)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub timecondition: Option<u64>,
}

/// \- Retrieves a list of Timezones if no additional parameter is provided.
/// \- Retrieves a specific Timezone if a timezone code is provided.
///
/// Parameters for [`Client::get_timezones`] (wire method `getTimezones`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetTimezonesParams {
    /// Code for a specific Time Zone (Example: 'America/Buenos_Aires')
    #[serde(
        skip_serializing_if = "Option::is_none",
        serialize_with = "crate::responses::serialize_opt_tz"
    )]
    pub timezone: Option<chrono_tz::Tz>,
}

/// \- Retrieves the Transaction History records between two dates.
///
/// Parameters for [`Client::get_transaction_history`] (wire method `getTransactionHistory`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetTransactionHistoryParams {
    /// Start Date for Filtering Transactions (Example: '2016-06-03') (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub date_from: Option<chrono::NaiveDate>,
    /// End Date for Filtering Transactions (Example: '2016-06-04') (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub date_to: Option<chrono::NaiveDate>,
}

/// \- Retrieves a list of vpri.
///
/// Parameters for [`Client::get_vpris`] (wire method `getVPRIs`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetVPRIsParams {}

/// \- Retrieves a list of Email Attachment Format Options if no additional
/// parameter is provided.
/// \- Retrieves a specific Email Attachment Format Option if a format value is
/// provided.
///
/// Parameters for [`Client::get_voicemail_attachment_formats`] (wire method `getVoicemailAttachmentFormats`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetVoicemailAttachmentFormatsParams {
    /// ID for a specific attachment format (Example: wav49)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub email_attachment_format: Option<EmailAttachmentFormat>,
}

/// \- Retrieves a list of default Voicemail Folders if no additional parameter
/// is provided.
/// \- Retrieves a list of Voicemail Folders within a mailbox if mailbox
/// parameter is provided.
/// \- Retrieves a specific Folder if a folder name is provided.
///
/// Parameters for [`Client::get_voicemail_folders`] (wire method `getVoicemailFolders`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetVoicemailFoldersParams {
    /// Folder Name (Example: 'INBOX')
    #[serde(skip_serializing_if = "Option::is_none")]
    pub folder: Option<VoicemailFolder>,
}

/// \- Retrieves a specific Voicemail Message File in Base64 format.
///
/// Parameters for [`Client::get_voicemail_message_file`] (wire method `getVoicemailMessageFile`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetVoicemailMessageFileParams {
    /// ID for specific Mailbox (Example: 1001) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub mailbox: Option<String>,
    /// Name for specific Folder (Example: 'INBOX', values from:
    /// getVoicemailFolders) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub folder: Option<VoicemailFolder>,
    /// ID for specific Voicemail Message (Example: 1) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub message_num: Option<u64>,
}

/// \- Retrieves a list of Voicemail Messages if mailbox parameter is provided.
/// \- Retrieves a list of Voicemail Messages in a Folder if a folder is
/// provided.
/// \- Retrieves a list of Voicemail Messages in a date range if a from and to
/// are provided.
///
/// Parameters for [`Client::get_voicemail_messages`] (wire method `getVoicemailMessages`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetVoicemailMessagesParams {
    /// ID for specific Mailbox (Example: 1001) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub mailbox: Option<String>,
    /// Name for specific Folder (Example: 'INBOX', values from:
    /// getVoicemailFolders)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub folder: Option<VoicemailFolder>,
    /// Start Date for Filtering Voicemail Messages (Example: '2016-01-30')
    #[serde(skip_serializing_if = "Option::is_none")]
    pub date_from: Option<chrono::NaiveDate>,
    /// End Date for Filtering Voicemail Messages (Example: '2016-01-30')
    #[serde(skip_serializing_if = "Option::is_none")]
    pub date_to: Option<chrono::NaiveDate>,
}

/// \- Retrieves a list of Voicemail Setup Options if no additional parameter is
/// provided.
/// \- Retrieves a specific Voicemail Setup Option if a voicemail setup code is
/// provided.
///
/// Parameters for [`Client::get_voicemail_setups`] (wire method `getVoicemailSetups`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetVoicemailSetupsParams {
    /// ID for a specific Voicemail Setup (Example: 2)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub voicemailsetup: Option<String>,
}

/// \- Retrieves all Voicemail Transcriptions if no additional parameter is
/// provided.
///
/// 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>,
    /// ID for specific Mailbox (Example: 1001) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub mailbox: Option<String>,
    /// End Date for Filtering (Example: '2010-11-30') (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub date_to: Option<chrono::NaiveDate>,
    /// Start Date for Filtering (Example: '2010-11-30') (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub date_from: Option<chrono::NaiveDate>,
    /// Name for specific Folder (Example: 'INBOX', values from:
    /// getVoicemailFolders) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub folder: Option<VoicemailFolder>,
}

/// \- Retrieves a list of Voicemails if no additional parameter is provided.
/// \- Retrieves a specific Voicemail if a voicemail code is provided.
///
/// Parameters for [`Client::get_voicemails`] (wire method `getVoicemails`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct GetVoicemailsParams {
    /// ID for specific Mailbox (Example: 1001)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub mailbox: Option<String>,
}

/// \- Send a Fax Message attached as a PDF file to an email destination.
///
/// Parameters for [`Client::mail_fax_message_pdf`] (wire method `mailFaxMessagePDF`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct MailFAXMessagePDFParams {
    /// ID of the Fax Message requested (Values from getFaxMessages) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub id: Option<u64>,
    /// Destination email adreess (example: \[email protected\]) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub email: Option<String>,
}

/// \- Mark a Voicemail Message as Listened or Unlistened.
/// \- If value is 'yes', the voicemail message will be marked as listened and
/// will be moved to the Old Folder.
/// \- If value is 'no', the voicemail message will be marked as not-listened and
/// will be moved to the INBOX Folder.
///
/// Parameters for [`Client::mark_listened_voicemail_message`] (wire method `markListenedVoicemailMessage`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct MarkListenedVoicemailMessageParams {
    /// ID for specific Mailbox (Example: 1001) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub mailbox: Option<String>,
    /// Name for specific Folder (Example: 'INBOX', values from:
    /// getVoicemailFolders) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub folder: Option<VoicemailFolder>,
    /// ID for specific Voicemail Message (Example: 1) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub message_num: Option<u64>,
    /// Code for mark voicemail as listened or not-listened (Values: 'yes'/'no')
    /// (required)
    #[serde(
        skip_serializing_if = "Option::is_none",
        serialize_with = "crate::responses::serialize_opt_flag_yes_no"
    )]
    pub listened: Option<bool>,
}

/// \- Mark Voicemail Message as Urgent or not Urgent.
/// \- If value is 'yes', the voicemail message will be marked as urgent and will
/// be moved to the Urgent Folder.
/// \- If value is 'no', the voicemail message will be unmarked as urgent and
/// will be moved to the INBOX Folder.
///
/// Parameters for [`Client::mark_urgent_voicemail_message`] (wire method `markUrgentVoicemailMessage`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct MarkUrgentVoicemailMessageParams {
    /// ID for specific Mailbox (Example: 1001) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub mailbox: Option<String>,
    /// Name for specific Folder (Example: 'INBOX', values from:
    /// getVoicemailFolders) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub folder: Option<VoicemailFolder>,
    /// ID for specific Voicemail Message (Example: 1) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub message_num: Option<u64>,
    /// Code for mark voicemail as urgent or not-urgent (Values: 'yes'/'no')
    /// (required)
    #[serde(
        skip_serializing_if = "Option::is_none",
        serialize_with = "crate::responses::serialize_opt_flag_yes_no"
    )]
    pub urgent: Option<bool>,
}

/// \- Moves a Fax Message to a different folder.
///
/// Parameters for [`Client::move_fax_message`] (wire method `moveFaxMessage`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct MoveFAXMessageParams {
    /// ID of the Fax Message requested (Values from getFaxMessages) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub fax_id: Option<u64>,
    /// ID of the destination Fax Folder (Values from getFaxFolders) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub folder_id: Option<u64>,
    /// Set to true if testing how to move a Fax Message
    #[serde(
        skip_serializing_if = "crate::responses::is_false",
        serialize_with = "crate::responses::serialize_flag_01"
    )]
    pub test: bool,
}

/// \- Move Voicemail Message to a Destination Folder.
///
/// Parameters for [`Client::move_folder_voicemail_message`] (wire method `moveFolderVoicemailMessage`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct MoveFolderVoicemailMessageParams {
    /// ID for specific Mailbox (Example: 1001) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub mailbox: Option<String>,
    /// Name for specific Folder (Example: 'INBOX', values from:
    /// getVoicemailFolders) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub folder: Option<VoicemailFolder>,
    /// ID for specific Voicemail Message (Example: 1) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub message_num: Option<u64>,
    /// Destination Folder (Example: 'Urgent', values from: getVoicemailFolders)
    /// (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub new_folder: Option<String>,
}

/// \- Orders and Adds a new DID Number to the Account.
///
/// Parameters for [`Client::order_did`] (wire method `orderDID`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct OrderDIDParams {
    /// DID to be Ordered (Example: 5552223333) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub did: Option<String>,
    /// Main Routing for the DID (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub routing: Option<crate::Routing>,
    /// Busy Routing for the DID
    #[serde(skip_serializing_if = "Option::is_none")]
    pub failover_busy: Option<crate::Routing>,
    /// Unreachable Routing for the DID
    #[serde(skip_serializing_if = "Option::is_none")]
    pub failover_unreachable: Option<crate::Routing>,
    /// NoAnswer Routing for the DID
    #[serde(skip_serializing_if = "Option::is_none")]
    pub failover_noanswer: Option<crate::Routing>,
    /// Voicemail for the DID (Example: 101)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub voicemail: Option<String>,
    /// Point of Presence for the DID (Example: 5) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pop: Option<u64>,
    /// Dial Time Out for the DID (Example: 60 -> in seconds) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub dialtime: Option<u64>,
    /// CNAM for the DID (Boolean: 1/0) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cnam: Option<u64>,
    /// Caller ID Prefix for the DID
    #[serde(skip_serializing_if = "Option::is_none")]
    pub callerid_prefix: Option<String>,
    /// Note for the DID
    #[serde(skip_serializing_if = "Option::is_none")]
    pub note: Option<String>,
    /// Billing type for the DID (1 = Per Minute, 2 = Flat) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub billing_type: Option<DidBillingType>,
    /// Reseller Sub Account (Example: '100001_VoIP')
    #[serde(skip_serializing_if = "Option::is_none")]
    pub account: Option<String>,
    /// Montly Fee for Reseller Client (Example: 3.50)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub monthly: Option<String>,
    /// Setup Fee for Reseller Client (Example: 1.99)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub setup: Option<String>,
    /// Minute Rate for Reseller Client (Example: 0.03)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub minute: Option<String>,
    /// Set to true if testing how Orders work - Orders can not be undone - When
    /// testing, no Orders are made routing, failover_busy, failover_unreachable
    /// and failover_noanswer can receive values in the following format =>
    /// header:record_id Where header could be: account, fwd, vm, sip, grp, ivr,
    /// sys, recording, queue, cb, tc, disa, none. Examples: account Used for
    /// routing calls to Sub Accounts You can get all sub accounts using the
    /// getSubAccounts function fwd Used for routing calls to Forwarding
    /// entries. You can get the ID right after creating a Forwarding with
    /// setForwarding or by requesting all forwardings entries with
    /// getForwardings. vm Used for routing calls to a Voicemail. You can get
    /// all voicemails and their IDs using the getVoicemails function sys System
    /// Options: hangup = Hangup the Call busy = Busy tone noservice = System
    /// Recording: Number not in service disconnected = System Recording: Number
    /// has been disconnected dtmf = DTMF Test echo = Sound Quality Test none
    /// Used to route calls to no action Examples: 'account:100001_VoIP'
    /// 'fwd:1026' 'vm:101' 'none:' 'sys:echo'
    #[serde(
        skip_serializing_if = "crate::responses::is_false",
        serialize_with = "crate::responses::serialize_flag_01"
    )]
    pub test: bool,
}

/// \- Orders and Adds new International Geographic DID Numbers to the Account.
///
/// Parameters for [`Client::order_did_international_geographic`] (wire method `orderDIDInternationalGeographic`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct OrderDIDInternationalGeographicParams {
    /// ID for a specific International Location (Values from
    /// getDIDsInternationalGeographic) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub location_id: Option<String>,
    /// Number of dids to be purchased (Example: 2) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub quantity: Option<u64>,
    /// Main Routing for the DID (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub routing: Option<crate::Routing>,
    /// Busy Routing for the DID
    #[serde(skip_serializing_if = "Option::is_none")]
    pub failover_busy: Option<crate::Routing>,
    /// Unreachable Routing for the DID
    #[serde(skip_serializing_if = "Option::is_none")]
    pub failover_unreachable: Option<crate::Routing>,
    /// NoAnswer Routing for the DID
    #[serde(skip_serializing_if = "Option::is_none")]
    pub failover_noanswer: Option<crate::Routing>,
    /// Voicemail for the DID (Example: 101)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub voicemail: Option<String>,
    /// Point of Presence for the DID (Example: 5) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pop: Option<u64>,
    /// Dial Time Out for the DID (Example: 60 -> in seconds) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub dialtime: Option<u64>,
    /// CNAM for the DID (Boolean: 1/0) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cnam: Option<String>,
    /// Caller ID Prefix for the DID
    #[serde(skip_serializing_if = "Option::is_none")]
    pub callerid_prefix: Option<String>,
    /// Billing type for the DID (1 = Per Minute, 2 = Flat) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub billing_type: Option<DidBillingType>,
    /// Note for the DID
    #[serde(skip_serializing_if = "Option::is_none")]
    pub note: Option<String>,
    /// Reseller Sub Account (Example: '100001_VoIP')
    #[serde(skip_serializing_if = "Option::is_none")]
    pub account: Option<String>,
    /// Montly Fee for Reseller Client (Example: 3.50)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub monthly: Option<String>,
    /// Setup Fee for Reseller Client (Example: 1.99)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub setup: Option<String>,
    /// Minute Rate for Reseller Client (Example: 0.03)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub minute: Option<String>,
    /// Set to true if testing how Orders work - Orders can not be undone - When
    /// testing, no Orders are made routing, failover_busy, failover_unreachable
    /// and failover_noanswer can receive values in the following format =>
    /// header:record_id Where header could be: account, fwd, vm, sip, grp, ivr,
    /// sys, recording, queue, cb, tc, disa, none. Examples: account Used for
    /// routing calls to Sub Accounts You can get all sub accounts using the
    /// getSubAccounts function fwd Used for routing calls to Forwarding
    /// entries. You can get the ID right after creating a Forwarding with
    /// setForwarding or by requesting all forwardings entries with
    /// getForwardings. vm Used for routing calls to a Voicemail. You can get
    /// all voicemails and their IDs using the getVoicemails function sys System
    /// Options: hangup = Hangup the Call busy = Busy tone noservice = System
    /// Recording: Number not in service disconnected = System Recording: Number
    /// has been disconnected dtmf = DTMF Test echo = Sound Quality Test none
    /// Used to route calls to no action Examples: 'account:100001_VoIP'
    /// 'fwd:1026' 'vm:101' 'none:' 'sys:echo'
    #[serde(
        skip_serializing_if = "crate::responses::is_false",
        serialize_with = "crate::responses::serialize_flag_01"
    )]
    pub test: bool,
}

/// \- Orders and Adds new International National DID Numbers to the Account.
///
/// Parameters for [`Client::order_did_international_national`] (wire method `orderDIDInternationalNational`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct OrderDIDInternationalNationalParams {
    /// ID for a specific International Location (Values from
    /// getDIDsInternationalNational) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub location_id: Option<String>,
    /// Number of dids to be purchased (Example: 2) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub quantity: Option<u64>,
    /// Main Routing for the DID (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub routing: Option<crate::Routing>,
    /// Busy Routing for the DID
    #[serde(skip_serializing_if = "Option::is_none")]
    pub failover_busy: Option<crate::Routing>,
    /// Unreachable Routing for the DID
    #[serde(skip_serializing_if = "Option::is_none")]
    pub failover_unreachable: Option<crate::Routing>,
    /// NoAnswer Routing for the DID
    #[serde(skip_serializing_if = "Option::is_none")]
    pub failover_noanswer: Option<crate::Routing>,
    /// Voicemail for the DID (Example: 101)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub voicemail: Option<String>,
    /// Point of Presence for the DID (Example: 5) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pop: Option<u64>,
    /// Dial Time Out for the DID (Example: 60 -> in seconds) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub dialtime: Option<u64>,
    /// CNAM for the DID (Boolean: 1/0) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cnam: Option<String>,
    /// Caller ID Prefix for the DID
    #[serde(skip_serializing_if = "Option::is_none")]
    pub callerid_prefix: Option<String>,
    /// Billing type for the DID (1 = Per Minute, 2 = Flat) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub billing_type: Option<DidBillingType>,
    /// Note for the DID
    #[serde(skip_serializing_if = "Option::is_none")]
    pub note: Option<String>,
    /// Reseller Sub Account (Example: '100001_VoIP')
    #[serde(skip_serializing_if = "Option::is_none")]
    pub account: Option<String>,
    /// Montly Fee for Reseller Client (Example: 3.50)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub monthly: Option<String>,
    /// Setup Fee for Reseller Client (Example: 1.99)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub setup: Option<String>,
    /// Minute Rate for Reseller Client (Example: 0.03)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub minute: Option<String>,
    /// Set to true if testing how Orders work - Orders can not be undone - When
    /// testing, no Orders are made routing, failover_busy, failover_unreachable
    /// and failover_noanswer can receive values in the following format =>
    /// header:record_id Where header could be: account, fwd, vm, sip, grp, ivr,
    /// sys, recording, queue, cb, tc, disa, none. Examples: account Used for
    /// routing calls to Sub Accounts You can get all sub accounts using the
    /// getSubAccounts function fwd Used for routing calls to Forwarding
    /// entries. You can get the ID right after creating a Forwarding with
    /// setForwarding or by requesting all forwardings entries with
    /// getForwardings. vm Used for routing calls to a Voicemail. You can get
    /// all voicemails and their IDs using the getVoicemails function sys System
    /// Options: hangup = Hangup the Call busy = Busy tone noservice = System
    /// Recording: Number not in service disconnected = System Recording: Number
    /// has been disconnected dtmf = DTMF Test echo = Sound Quality Test none
    /// Used to route calls to no action Examples: 'account:100001_VoIP'
    /// 'fwd:1026' 'vm:101' 'none:' 'sys:echo'
    #[serde(
        skip_serializing_if = "crate::responses::is_false",
        serialize_with = "crate::responses::serialize_flag_01"
    )]
    pub test: bool,
}

/// \- Orders and Adds new International TollFree DID Numbers to the Account.
///
/// Parameters for [`Client::order_did_international_toll_free`] (wire method `orderDIDInternationalTollFree`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct OrderDIDInternationalTollFreeParams {
    /// ID for a specific International Location (Values from
    /// getDIDsInternationalTollFree) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub location_id: Option<String>,
    /// Number of dids to be purchased (Example: 2) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub quantity: Option<u64>,
    /// Main Routing for the DID (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub routing: Option<crate::Routing>,
    /// Busy Routing for the DID
    #[serde(skip_serializing_if = "Option::is_none")]
    pub failover_busy: Option<crate::Routing>,
    /// Unreachable Routing for the DID
    #[serde(skip_serializing_if = "Option::is_none")]
    pub failover_unreachable: Option<crate::Routing>,
    /// NoAnswer Routing for the DID
    #[serde(skip_serializing_if = "Option::is_none")]
    pub failover_noanswer: Option<crate::Routing>,
    /// Voicemail for the DID (Example: 101)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub voicemail: Option<String>,
    /// Point of Presence for the DID (Example: 5) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pop: Option<u64>,
    /// Dial Time Out for the DID (Example: 60 -> in seconds) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub dialtime: Option<u64>,
    /// CNAM for the DID (Boolean: 1/0) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cnam: Option<String>,
    /// Caller ID Prefix for the DID
    #[serde(skip_serializing_if = "Option::is_none")]
    pub callerid_prefix: Option<String>,
    /// Note for the DID
    #[serde(skip_serializing_if = "Option::is_none")]
    pub note: Option<String>,
    /// Reseller Sub Account (Example: '100001_VoIP')
    #[serde(skip_serializing_if = "Option::is_none")]
    pub account: Option<String>,
    /// Montly Fee for Reseller Client (Example: 3.50)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub monthly: Option<String>,
    /// Setup Fee for Reseller Client (Example: 1.99)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub setup: Option<String>,
    /// Minute Rate for Reseller Client (Example: 0.03)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub minute: Option<String>,
    /// Set to true if testing how Orders work - Orders can not be undone - When
    /// testing, no Orders are made routing, failover_busy, failover_unreachable
    /// and failover_noanswer can receive values in the following format =>
    /// header:record_id Where header could be: account, fwd, vm, sip, grp, ivr,
    /// sys, recording, queue, cb, tc, disa, none. Examples: account Used for
    /// routing calls to Sub Accounts You can get all sub accounts using the
    /// getSubAccounts function fwd Used for routing calls to Forwarding
    /// entries. You can get the ID right after creating a Forwarding with
    /// setForwarding or by requesting all forwardings entries with
    /// getForwardings. vm Used for routing calls to a Voicemail. You can get
    /// all voicemails and their IDs using the getVoicemails function sys System
    /// Options: hangup = Hangup the Call busy = Busy tone noservice = System
    /// Recording: Number not in service disconnected = System Recording: Number
    /// has been disconnected dtmf = DTMF Test echo = Sound Quality Test none
    /// Used to route calls to no action Examples: 'account:100001_VoIP'
    /// 'fwd:1026' 'vm:101' 'none:' 'sys:echo'
    #[serde(
        skip_serializing_if = "crate::responses::is_false",
        serialize_with = "crate::responses::serialize_flag_01"
    )]
    pub test: bool,
}

/// \- Orders and Adds a new Virtual DID Number to the Account.
///
/// Parameters for [`Client::order_did_virtual`] (wire method `orderDIDVirtual`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct OrderDIDVirtualParams {
    /// Three Digits for the new Virtual DID (Example: 001) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub digits: Option<u64>,
    /// Main Routing for the DID (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub routing: Option<crate::Routing>,
    /// Busy Routing for the DID
    #[serde(skip_serializing_if = "Option::is_none")]
    pub failover_busy: Option<crate::Routing>,
    /// Unreachable Routing for the DID
    #[serde(skip_serializing_if = "Option::is_none")]
    pub failover_unreachable: Option<crate::Routing>,
    /// NoAnswer Routing for the DID
    #[serde(skip_serializing_if = "Option::is_none")]
    pub failover_noanswer: Option<crate::Routing>,
    /// Voicemail for the DID (Example: 101)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub voicemail: Option<String>,
    /// Point of Presence for the DID (Example: 5) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pop: Option<u64>,
    /// Dial Time Out for the DID (Example: 60 -> in seconds) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub dialtime: Option<u64>,
    /// CNAM for the DID (Boolean: 1/0) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cnam: Option<String>,
    /// Caller ID Prefix for the DID
    #[serde(skip_serializing_if = "Option::is_none")]
    pub callerid_prefix: Option<String>,
    /// Note for the DID
    #[serde(skip_serializing_if = "Option::is_none")]
    pub note: Option<String>,
    /// Reseller Sub Account (Example: '100001_VoIP')
    #[serde(skip_serializing_if = "Option::is_none")]
    pub account: Option<String>,
    /// Montly Fee for Reseller Client (Example: 3.50)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub monthly: Option<String>,
    /// Setup Fee for Reseller Client (Example: 1.99)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub setup: Option<String>,
    /// Minute Rate for Reseller Client (Example: 0.03)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub minute: Option<String>,
    /// Set to true if testing how Orders work - Orders can not be undone - When
    /// testing, no Orders are made routing, failover_busy, failover_unreachable
    /// and failover_noanswer can receive values in the following format =>
    /// header:record_id Where header could be: account, fwd, vm, sip, grp, ivr,
    /// sys, recording, queue, cb, tc, disa, none. Examples: account Used for
    /// routing calls to Sub Accounts You can get all sub accounts using the
    /// getSubAccounts function fwd Used for routing calls to Forwarding
    /// entries. You can get the ID right after creating a Forwarding with
    /// setForwarding or by requesting all forwardings entries with
    /// getForwardings. vm Used for routing calls to a Voicemail. You can get
    /// all voicemails and their IDs using the getVoicemails function sys System
    /// Options: hangup = Hangup the Call busy = Busy tone noservice = System
    /// Recording: Number not in service disconnected = System Recording: Number
    /// has been disconnected dtmf = DTMF Test echo = Sound Quality Test none
    /// Used to route calls to no action Examples: 'account:100001_VoIP'
    /// 'fwd:1026' 'vm:101' 'none:' 'sys:echo'
    #[serde(
        skip_serializing_if = "crate::responses::is_false",
        serialize_with = "crate::responses::serialize_flag_01"
    )]
    pub test: bool,
}

/// \- Orders and Adds a new Fax Number to the Account.
///
/// Parameters for [`Client::order_fax_number`] (wire method `orderFaxNumber`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct OrderFAXNumberParams {
    /// Location ID of the Fax Number (Values from
    /// getFaxRateCentersCAN/getFaxRateCentersUSA) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub location: Option<u64>,
    /// Quantity of Fax Numbers to order (Example: 3) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub quantity: Option<u64>,
    /// Email address where send notifications when receive Fax Messages -
    /// (Example: \[email protected\])
    #[serde(skip_serializing_if = "Option::is_none")]
    pub email: Option<String>,
    /// Flag to enable the email notifications. - (Values: 1 = true, 0 = false)
    /// \- Default: 0
    #[serde(
        skip_serializing_if = "Option::is_none",
        serialize_with = "crate::responses::serialize_opt_flag_01"
    )]
    pub email_enable: Option<bool>,
    /// Flag to enable attach the Fax Message as a PDF file in the
    /// notifications. - (Values: 1 = true, 0 = false) - Default: 0
    #[serde(
        skip_serializing_if = "Option::is_none",
        serialize_with = "crate::responses::serialize_opt_flag_01"
    )]
    pub email_attach_file: Option<bool>,
    /// URL where make a POST when you receive a Fax Message.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub url_callback: Option<String>,
    /// Flag to enable the URL Callback functionality. - (Values: 1 = true, 0 =
    /// false) - Default: 0
    #[serde(
        skip_serializing_if = "Option::is_none",
        serialize_with = "crate::responses::serialize_opt_flag_01"
    )]
    pub url_callback_enable: Option<bool>,
    /// Flag to enable retry the POST action in case we don't receive "ok".
    #[serde(
        skip_serializing_if = "Option::is_none",
        serialize_with = "crate::responses::serialize_opt_flag_01"
    )]
    pub url_callback_retry: Option<bool>,
    /// Set to true if testing how Orders work - Orders can not be undone - When
    /// testing, no Orders are made
    #[serde(
        skip_serializing_if = "crate::responses::is_false",
        serialize_with = "crate::responses::serialize_flag_01"
    )]
    pub test: bool,
}

/// \- Orders and Adds a new Toll Free Number to the Account.
///
/// Parameters for [`Client::order_toll_free`] (wire method `orderTollFree`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct OrderTollFreeParams {
    /// DID to be Ordered (Example: 8772223333) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub did: Option<String>,
    /// Main Routing for the DID (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub routing: Option<crate::Routing>,
    /// Busy Routing for the DID
    #[serde(skip_serializing_if = "Option::is_none")]
    pub failover_busy: Option<crate::Routing>,
    /// Unreachable Routing for the DID
    #[serde(skip_serializing_if = "Option::is_none")]
    pub failover_unreachable: Option<crate::Routing>,
    /// NoAnswer Routing for the DID
    #[serde(skip_serializing_if = "Option::is_none")]
    pub failover_noanswer: Option<crate::Routing>,
    /// Voicemail for the DID (Example: 101)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub voicemail: Option<String>,
    /// Point of Presence for the DID (Example: 5) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pop: Option<u64>,
    /// Dial Time Out for the DID (Example: 60 -> in seconds) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub dialtime: Option<u64>,
    /// CNAM for the DID (Boolean: 1/0) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cnam: Option<u64>,
    /// Caller ID Prefix for the DID
    #[serde(skip_serializing_if = "Option::is_none")]
    pub callerid_prefix: Option<String>,
    /// Note for the DID
    #[serde(skip_serializing_if = "Option::is_none")]
    pub note: Option<String>,
    /// Reseller Sub Account (Example: '100001_VoIP')
    #[serde(skip_serializing_if = "Option::is_none")]
    pub account: Option<String>,
    /// Montly Fee for Reseller Client (Example: 3.50)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub monthly: Option<String>,
    /// Setup Fee for Reseller Client (Example: 1.99)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub setup: Option<String>,
    /// Minute Rate for Reseller Client (Example: 0.03)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub minute: Option<String>,
    /// Set to true if testing how Orders work - Orders can not be undone - When
    /// testing, no Orders are made routing, failover_busy, failover_unreachable
    /// and failover_noanswer can receive values in the following format =>
    /// header:record_id Where header could be: account, fwd, vm, sip, grp, ivr,
    /// sys, recording, queue, cb, tc, disa, none. Examples: account Used for
    /// routing calls to Sub Accounts You can get all sub accounts using the
    /// getSubAccounts function fwd Used for routing calls to Forwarding
    /// entries. You can get the ID right after creating a Forwarding with
    /// setForwarding or by requesting all forwardings entries with
    /// getForwardings. vm Used for routing calls to a Voicemail. You can get
    /// all voicemails and their IDs using the getVoicemails function sys System
    /// Options: hangup = Hangup the Call busy = Busy tone noservice = System
    /// Recording: Number not in service disconnected = System Recording: Number
    /// has been disconnected dtmf = DTMF Test echo = Sound Quality Test none
    /// Used to route calls to no action Examples: 'account:100001_VoIP'
    /// 'fwd:1026' 'vm:101' 'none:' 'sys:echo'
    #[serde(
        skip_serializing_if = "crate::responses::is_false",
        serialize_with = "crate::responses::serialize_flag_01"
    )]
    pub test: bool,
}

/// \- Orders and Adds a new Vanity Toll Free Number to the Account.
///
/// Parameters for [`Client::order_vanity`] (wire method `orderVanity`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct OrderVanityParams {
    /// DID to be Ordered (Example: 8772223333) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub did: Option<String>,
    /// Main Routing for the DID (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub routing: Option<crate::Routing>,
    /// Busy Routing for the DID
    #[serde(skip_serializing_if = "Option::is_none")]
    pub failover_busy: Option<crate::Routing>,
    /// Unreachable Routing for the DID
    #[serde(skip_serializing_if = "Option::is_none")]
    pub failover_unreachable: Option<crate::Routing>,
    /// NoAnswer Routing for the DID
    #[serde(skip_serializing_if = "Option::is_none")]
    pub failover_noanswer: Option<crate::Routing>,
    /// Voicemail for the DID (Example: 101)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub voicemail: Option<String>,
    /// Point of Presence for the DID (Example: 5) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pop: Option<u64>,
    /// Dial Time Out for the DID (Example: 60 -> in seconds) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub dialtime: Option<u64>,
    /// CNAM for the DID (Boolean: 1/0) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cnam: Option<u64>,
    /// Caller ID Prefix for the DID
    #[serde(skip_serializing_if = "Option::is_none")]
    pub callerid_prefix: Option<String>,
    /// Note for the DID
    #[serde(skip_serializing_if = "Option::is_none")]
    pub note: Option<String>,
    /// Carrier for the DID (Values from getCarriers) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub carrier: Option<u64>,
    /// Reseller Sub Account (Example: '100001_VoIP')
    #[serde(skip_serializing_if = "Option::is_none")]
    pub account: Option<String>,
    /// Montly Fee for Reseller Client (Example: 3.50)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub monthly: Option<String>,
    /// Setup Fee for Reseller Client (Example: 1.99)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub setup: Option<String>,
    /// Minute Rate for Reseller Client (Example: 0.03)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub minute: Option<String>,
    /// Set to true if testing how Orders work - Orders can not be undone - When
    /// testing, no Orders are made routing, failover_busy, failover_unreachable
    /// and failover_noanswer can receive values in the following format =>
    /// header:record_id Where header could be: account, fwd, vm, sip, grp, ivr,
    /// sys, recording, queue, cb, tc, disa, none. Examples: account Used for
    /// routing calls to Sub Accounts You can get all sub accounts using the
    /// getSubAccounts function fwd Used for routing calls to Forwarding
    /// entries. You can get the ID right after creating a Forwarding with
    /// setForwarding or by requesting all forwardings entries with
    /// getForwardings. vm Used for routing calls to a Voicemail. You can get
    /// all voicemails and their IDs using the getVoicemails function sys System
    /// Options: hangup = Hangup the Call busy = Busy tone noservice = System
    /// Recording: Number not in service disconnected = System Recording: Number
    /// has been disconnected dtmf = DTMF Test echo = Sound Quality Test none
    /// Used to route calls to no action Examples: 'account:100001_VoIP'
    /// 'fwd:1026' 'vm:101' 'none:' 'sys:echo'
    #[serde(
        skip_serializing_if = "crate::responses::is_false",
        serialize_with = "crate::responses::serialize_flag_01"
    )]
    pub test: bool,
}

/// \- Removes a DID from a VPRI
///
/// Parameters for [`Client::remove_did_vpri`] (wire method `removeDIDvPRI`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct RemoveDIDvPRIParams {
    /// Id for specific Vpri
    #[serde(skip_serializing_if = "Option::is_none")]
    pub vpri: Option<u64>,
    /// DID Number to be remove from our Vpri (Example: 561115) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub did: Option<String>,
}

/// \- Searches for Canadian DIDs by Province using a Search Criteria.
///
/// Parameters for [`Client::search_dids_can`] (wire method `searchDIDsCAN`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct SearchDIDsCANParams {
    /// Canadian Province (Values from getProvinces)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub province: Option<String>,
    /// Type of search (Values: 'starts', 'contains', 'ends') (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub r#type: Option<SearchType>,
    /// Query for searching (Examples: 'JOHN', '555', '123ABC') (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub query: Option<String>,
}

/// \- Searches for USA DIDs by State using a Search Criteria.
///
/// Parameters for [`Client::search_dids_usa`] (wire method `searchDIDsUSA`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct SearchDIDsUSAParams {
    /// United States State (Values from getStates)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub state: Option<String>,
    /// Type of search (Values: 'starts', 'contains', 'ends') (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub r#type: Option<SearchType>,
    /// Query for searching (Examples: 'JOHN', '555', '123ABC') (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub query: Option<String>,
}

/// \- Retrieves a list of Canadian Ratecenters searched by Area Code.
///
/// Parameters for [`Client::search_fax_area_code_can`] (wire method `searchFaxAreaCodeCAN`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct SearchFAXAreaCodeCANParams {
    /// Area code number, as the initial of the Fax Number you looking for.
    /// (values from getFaxRateCentersCAN) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub area_code: Option<u64>,
}

/// \- Retrieves a list of USA Ratecenters searched by Area Code.
///
/// Parameters for [`Client::search_fax_area_code_usa`] (wire method `searchFaxAreaCodeUSA`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct SearchFAXAreaCodeUSAParams {
    /// Area code number, as the initial of the Fax Number you looking for.
    /// (values from getFaxRateCentersUSA) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub area_code: Option<u64>,
}

/// \- Searches for USA/Canada Toll Free Numbers using a Search Criteria.
/// \- Shows all USA/Canada Toll Free Numbers available if no criteria is
/// provided.
///
/// Parameters for [`Client::search_toll_free_can_us`] (wire method `searchTollFreeCanUS`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct SearchTollFreeCANUSParams {
    /// Type of search (Values: 'starts', 'contains', 'ends')
    #[serde(skip_serializing_if = "Option::is_none")]
    pub r#type: Option<SearchType>,
    /// Query for searching (Examples: 'JOHN', '555', '123ABC')
    #[serde(skip_serializing_if = "Option::is_none")]
    pub query: Option<String>,
}

/// \- Searches for USA Toll Free Numbers using a Search Criteria.
/// \- Shows all USA Toll Free Numbers available if no criteria is provided.
///
/// Parameters for [`Client::search_toll_free_usa`] (wire method `searchTollFreeUSA`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct SearchTollFreeUSAParams {
    /// Type of search (Values: 'starts', 'contains', 'ends')
    #[serde(skip_serializing_if = "Option::is_none")]
    pub r#type: Option<SearchType>,
    /// Query for searching (Examples: 'JOHN', '555', '123ABC')
    #[serde(skip_serializing_if = "Option::is_none")]
    pub query: Option<String>,
}

/// \- Searches for Vanity Toll Free Numbers using a Search Criteria.
///
/// Parameters for [`Client::search_vanity`] (wire method `searchVanity`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct SearchVanityParams {
    /// Type of Vanity Number Values: '8**', '800', '833', '844', '855', '866',
    /// '877', '888' (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub r#type: Option<VanityType>,
    /// Query for searching : 7 Chars Examples: '***JHON', '**555**', '**HELLO'
    /// (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub query: Option<String>,
}

/// \- Send information and audio file to email account.
///
/// Parameters for [`Client::send_call_recording_email`] (wire method `sendCallRecordingEmail`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct SendCallRecordingEmailParams {
    /// Call Recording (Values from getCallRecordings) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub callrecording: Option<String>,
    /// Filter Call Recordings by Account (Values from getCallAccounts)
    /// (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub account: Option<String>,
    /// Email to send call recording (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub email: Option<String>,
}

/// \- Send a Fax message to a Destination Number.
///
/// Parameters for [`Client::send_fax_message`] (wire method `sendFaxMessage`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct SendFAXMessageParams {
    /// Destination DID Number (Example: 5552341234) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub to_number: Option<String>,
    /// Name of the sender (Example: 5552341234) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub from_name: Option<String>,
    /// DID number of the Fax sender (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub from_number: Option<String>,
    /// Flag to enable the send of a copy of your Fax via email. - (Values: 1 =
    /// true, 0 = false) - Default: 0
    #[serde(
        skip_serializing_if = "Option::is_none",
        serialize_with = "crate::responses::serialize_opt_flag_01"
    )]
    pub send_email_enabled: Option<bool>,
    /// Email address where you want send a copy of your Fax.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub send_email: Option<String>,
    /// An word to identify a equipment or department sending the Fax.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub station_id: Option<String>,
    /// The file must be encoded in Base64, and in one of the following formats:
    /// pdf, txt, jpg, gif, png, tif (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub file: Option<String>,
    /// Set to true if testing how to send a Fax Message
    #[serde(
        skip_serializing_if = "crate::responses::is_false",
        serialize_with = "crate::responses::serialize_flag_01"
    )]
    pub test: bool,
}

/// \- Send a MMS message to a Destination Number.
///
/// Parameters for [`Client::send_mms`] (wire method `sendMMS`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct SendMMSParams {
    /// DID Numbers which is sending the message (Example: 5551234567)
    /// (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub did: Option<String>,
    /// Destination Number (Example: 5551234568) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub dst: Option<String>,
    /// Message to be sent (Example: 'hello John Smith' max chars: 2048)
    /// (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub message: Option<String>,
    /// Url to media file (Example:
    /// '<https://voip.ms/themes/voipms/assets/img/talent.jpg?v=2>' (optional)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub media1: Option<String>,
    /// Base 64 image encode (Example:
    /// data:image/png;base64,iVBORw0KGgoAAAANSUh...) (optional)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub media2: Option<String>,
    /// Empty value (Example: '' ) (optional)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub media3: Option<String>,
}

/// \- Send a SMS message to a Destination Number.
///
/// Parameters for [`Client::send_sms`] (wire method `sendSMS`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct SendSMSParams {
    /// DID Numbers which is sending the message (Example: 5551234567)
    /// (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub did: Option<String>,
    /// Destination Number (Example: 5551234568) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub dst: Option<String>,
    /// Message to be sent (Example: 'hello John Smith' max chars: 160)
    /// (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub message: Option<String>,
}

/// \- Send a Voicemail Message File to an Email Address.
///
/// Parameters for [`Client::send_voicemail_email`] (wire method `sendVoicemailEmail`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct SendVoicemailEmailParams {
    /// ID for specific Mailbox (Example: 1001) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub mailbox: Option<String>,
    /// Name for specific Folder (Example: 'INBOX', values from:
    /// getVoicemailFolders) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub folder: Option<VoicemailFolder>,
    /// ID for specific Voicemail Message (Example: 1) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub message_num: Option<u64>,
    /// Destination Email address (Example: \[email protected\]) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub email_address: Option<String>,
}

/// \- Updates a specific Call Hunting if a Call Hunting code is provided.
/// \- Adds a new Call Hunting if no Call Hunting code is provided.
///
/// Parameters for [`Client::set_call_hunting`] (wire method `setCallHunting`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct SetCallHuntingParams {
    /// ID for a specific Call Hunting (Example: 235 / Leave empty to create a
    /// new one)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub callhunting: Option<u64>,
    /// Description for the Call Hunting (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    /// Music on Hold Code (Values from getMusicOnHold) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub music: Option<String>,
    /// Recording for the Call Hunting (values from getRecordings) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub recording: Option<String>,
    /// Language for the Call Hunting (values from getLanguages) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub language: Option<String>,
    /// The members will be called in follow or random order (values follow or
    /// random) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub order: Option<RingGroupOrder>,
    /// The list of members assigned to the call hunting (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub members: Option<String>,
    /// The Maximum amount of time the call will ring the member (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ring_time: Option<String>,
    /// This option confirm if the member will take the call by pressing 1 *
    /// ring_time and press parameters need to have the same amount of items as
    /// the members parameter, one for each member. (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub press: Option<String>,
}

/// \- Updates a specific Call Parking entry if a Call Parking ID is provided.
/// \- Adds a new Call Parking entry if no Call Parking ID is provided.
///
/// Parameters for [`Client::set_call_parking`] (wire method `setCallParking`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct SetCallParkingParams {
    /// ID for a specific Call Parking (Example: 235 / Leave empty to create a
    /// new one)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub callparking: Option<u64>,
    /// Name for the Call Parking (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    /// The number of seconds a call will stay parked before it is forwarded to
    /// the Failover Destination (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub timeout: Option<u64>,
    /// Music on Hold Code (Values from getMusicOnHold) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub music: Option<String>,
    /// Final destination where the call will be forwarded if it isn&rsquo;t
    /// answered. (Values: callback, system:hangup, vm:mailbox) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub failover: Option<String>,
    /// Language for the Call Parking (values from getLanguages) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub language: Option<String>,
    /// The system will make an automatic call to this destination to announce
    /// the extension of the parked call. (Values: parker, main account or
    /// sub-accounts) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub destination: Option<String>,
    /// The number of seconds before the Announce Destination receives an
    /// automatic call from the system to announce the extension of the parked
    /// call (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub delay: Option<u64>,
}

/// \- Updates a specific Callback if a callback code is provided.
/// \- Adds a new Callback entry if no callback code is provided.
///
/// Parameters for [`Client::set_callback`] (wire method `setCallback`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct SetCallbackParams {
    /// ID for a specific Callback (Example: 2359 / Leave empty to create a new
    /// one)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub callback: Option<String>,
    /// Description for the Callback (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    /// Number that will be called back (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub number: Option<String>,
    /// Delay befor calling back (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub delay_before: Option<u64>,
    /// Time before hanging up for incomplete input (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub response_timeout: Option<u64>,
    /// Time between digits input (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub digit_timeout: Option<u64>,
    /// Caller ID Override for the callback
    #[serde(skip_serializing_if = "Option::is_none")]
    pub callerid_number: Option<String>,
}

/// \- Updates a specific Caller ID Filtering if a filtering code is provided.
/// \- Adds a new Caller ID Filtering if no filtering code is provided.
///
/// Parameters for [`Client::set_caller_id_filtering`] (wire method `setCallerIDFiltering`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct SetCallerIDFilteringParams {
    /// ID for a specific Caller ID Filtering (Example: 18915 / Leave empty to
    /// create a new one)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub filter: Option<String>,
    /// Caller ID that triggers the Filter (i = Not North American format, 0 =
    /// Anonymous, NPANXXXXXX, s or sb or sc = STIR/SHAKEN Attestation Level, p
    /// = All Phone Book, p:XXXX = Specific Phone Book Group) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub callerid: Option<String>,
    /// DIDs affected by the filter (all, NPANXXXXXX) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub did: Option<String>,
    /// Route the call follows when filter is triggered (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub routing: Option<crate::Routing>,
    /// Route the call follows when unreachable
    #[serde(skip_serializing_if = "Option::is_none")]
    pub failover_unreachable: Option<crate::Routing>,
    /// Route the call follows when busy
    #[serde(skip_serializing_if = "Option::is_none")]
    pub failover_busy: Option<crate::Routing>,
    /// Route the call follows when noanswer
    #[serde(skip_serializing_if = "Option::is_none")]
    pub failover_noanswer: Option<crate::Routing>,
    /// Note for the Caller ID Filtering
    #[serde(skip_serializing_if = "Option::is_none")]
    pub note: Option<String>,
}

/// \- Updates Reseller Client information.
///
/// Parameters for [`Client::set_client`] (wire method `setClient`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct SetClientParams {
    /// ID for a specific Reseller Client (Example: 561115) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub client: Option<u64>,
    /// Client's e-mail (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub email: Option<String>,
    /// Client's Password (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub password: Option<String>,
    /// Client's Company
    #[serde(skip_serializing_if = "Option::is_none")]
    pub company: Option<String>,
    /// Client's Firstname (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub firstname: Option<String>,
    /// Client's Lastname (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lastname: Option<String>,
    /// Client's Address
    #[serde(skip_serializing_if = "Option::is_none")]
    pub address: Option<String>,
    /// Client's City
    #[serde(skip_serializing_if = "Option::is_none")]
    pub city: Option<String>,
    /// Client's State
    #[serde(skip_serializing_if = "Option::is_none")]
    pub state: Option<String>,
    /// Client's Country (Values from getCountries)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub country: Option<String>,
    /// Client's Zip Code
    #[serde(skip_serializing_if = "Option::is_none")]
    pub zip: Option<String>,
    /// Client's Phone Number (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub phone_number: Option<String>,
    /// Balance Management for Client (Values from getBalanceManagement)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub balance_management: Option<u64>,
}

/// \- Update the Threshold Amount for a specific Reseller Client.- Update the
/// Threshold notification e-mail for a specific Reseller Client if the e-mail
/// address is provided.
///
/// Parameters for [`Client::set_client_threshold`] (wire method `setClientThreshold`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct SetClientThresholdParams {
    /// ID for a specific Reseller Client (Example: 561115) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub client: Option<u64>,
    /// Client's e-mail for balance threshold notification
    #[serde(skip_serializing_if = "Option::is_none")]
    pub email: Option<String>,
    /// Threshold amount between 1 and 250 (Example: 10) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub threshold: Option<u64>,
}

/// \- Updates a specific Conference if a conference code is provided.
/// \- Adds a new Conference entry if no conference code is provided.
///
/// Parameters for [`Client::set_conference`] (wire method `setConference`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct SetConferenceParams {
    /// ID for a specific Conference (Example: 5356) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub conference: Option<u64>,
    /// Conference name (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    /// Conference description (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    /// Conference Members
    #[serde(skip_serializing_if = "Option::is_none")]
    pub members: Option<String>,
    /// Members Max Value (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_members: Option<crate::MaxMembers>,
    /// The recording played when a user joins, typically some kind of beep
    /// sound (Values from getRecordings)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sound_join: Option<String>,
    /// The recording played when a user leaves, typically some kind of beep
    /// sound (Values from getRecordings)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sound_leave: Option<String>,
    /// The recording played as a user intro (Values from getRecordings)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sound_has_joined: Option<String>,
    /// The recording played as a user leaves the conference (Values from
    /// getRecordings)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sound_has_left: Option<String>,
    /// The recording played to a user who has been kicked from the conference
    /// (Values from getRecordings)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sound_kicked: Option<String>,
    /// The recording played to a user when the mute option is toggled on
    /// (Values from getRecordings)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sound_muted: Option<String>,
    /// The recording played to a user when the mute option is toggled off
    /// (Values from getRecordings)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sound_unmuted: Option<String>,
    /// The recording played when a user is the only person in the conference
    /// (Values from getRecordings)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sound_only_person: Option<String>,
    /// The recording played to a user when there is only one other person in
    /// the conference. (Values from getRecordings)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sound_only_one: Option<String>,
    /// The recording played when announcing how many users there are in a
    /// conference. (Values from getRecordings)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sound_there_are: Option<String>,
    /// The recording used in conjunction with the There are option, used like
    /// There are (number of participants) Other in party (Values from
    /// getRecordings)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sound_other_in_party: Option<String>,
    /// The recording played when a user is placed into a conference that cannot
    /// start until a marked user enters (Values from getRecordings)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sound_place_into_conference: Option<String>,
    /// The recording played when prompting for a conference PIN (Values from
    /// getRecordings)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sound_get_pin: Option<String>,
    /// The recording played when an invalid PIN is entered too many (3) times
    /// (Values from getRecordings)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sound_invalid_pin: Option<String>,
    /// The recording played to a user trying to join a locked conference
    /// (Values from getRecordings)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sound_locked: Option<String>,
    /// The recording played to an Admin-level user after toggling the
    /// conference to locked mode (Values from getRecordings)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sound_locked_now: Option<String>,
    /// The recording played to an Admin-level user after toggling the
    /// conference to unlocked mode (Values from getRecordings)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sound_unlocked_now: Option<String>,
    /// The recording played when there is an error on the menu. (Values from
    /// getRecordings)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sound_error_menu: Option<String>,
    /// The recording played when all non-admin participants are muted. (Values
    /// from getRecordings)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sound_participants_muted: Option<String>,
    /// The recording played when all non-admin participants are unmuted.
    /// (Values from getRecordings)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sound_participants_unmuted: Option<String>,
    /// Conference Language (Values from getLanguages)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub language: Option<String>,
}

/// \- Updates a specific Member profile if a member code is provided.
/// \- Adds a new Member profile entry if no member code is provided.
///
/// Parameters for [`Client::set_conference_member`] (wire method `setConferenceMember`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct SetConferenceMemberParams {
    /// ID for a specific Member profile (Example: 5356) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub member: Option<u64>,
    /// ID for a specific Conference (Example: 5356) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub conference: Option<u64>,
    /// Member name. (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    /// Member description.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    /// Assigned PIN.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pin: Option<u64>,
    /// Sets if the conference recording when a member joins or leaves will be
    /// played (yes/no).
    #[serde(
        skip_serializing_if = "Option::is_none",
        serialize_with = "crate::responses::serialize_opt_flag_yes_no"
    )]
    pub announce_join_leave: Option<bool>,
    /// Sets if the member is an admin or not (yes/no).
    #[serde(
        skip_serializing_if = "Option::is_none",
        serialize_with = "crate::responses::serialize_opt_flag_yes_no"
    )]
    pub admin: Option<bool>,
    /// Sets if the member should start out muted after entering the conference
    /// (yes/no).
    #[serde(
        skip_serializing_if = "Option::is_none",
        serialize_with = "crate::responses::serialize_opt_flag_yes_no"
    )]
    pub start_muted: Option<bool>,
    /// Sets if the number of members in the conference should be announced to
    /// the caller as he joins (yes/no).
    #[serde(
        skip_serializing_if = "Option::is_none",
        serialize_with = "crate::responses::serialize_opt_flag_yes_no"
    )]
    pub announce_user_count: Option<bool>,
    /// Sets if the "only user" announcement should be played when a caller
    /// enters an empty conference (yes/no).
    #[serde(
        skip_serializing_if = "Option::is_none",
        serialize_with = "crate::responses::serialize_opt_flag_yes_no"
    )]
    pub announce_only_user: Option<bool>,
    /// Sets whether music on hold (MOH) should be played when only one person
    /// is in the conference (Values from getMusicOnHold).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub moh_when_empty: Option<String>,
    /// When set to "yes", enter/leave prompts and user introductions are not
    /// played (yes/no).
    #[serde(
        skip_serializing_if = "Option::is_none",
        serialize_with = "crate::responses::serialize_opt_flag_yes_no"
    )]
    pub quiet: Option<bool>,
    /// If set, this recording will be heard only by the user as he joins the
    /// conference (Values from getRecordings).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub announcement: Option<u64>,
    /// The system will drop what is detected as silence from entering into the
    /// conference (yes/no).
    #[serde(
        skip_serializing_if = "Option::is_none",
        serialize_with = "crate::responses::serialize_opt_flag_yes_no"
    )]
    pub drop_silence: Option<bool>,
    /// The time, in milliseconds, that a users needs to be sending sound or
    /// voice before the system can consider them to be talking (allowed values
    /// are 100, 120, 140, 160, 180, 200, 220, 240 or 250).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub talking_threshold: Option<u64>,
    /// The time, in milliseconds, that silence needs to be present in the
    /// user&rsquo;s sound stream before the system can consider it to be in
    /// fact silent and close the audio (allowed values are 2000, 2100, 2200,
    /// 2300, 2400, 2500, 2600, 2700, 2800, 2900 or 3000).
    #[serde(skip_serializing_if = "Option::is_none")]
    pub silence_threshold: Option<u64>,
    /// If set to YES, the conference dashboard will display a notification when
    /// a participant starts and stops talking (yes/no).
    #[serde(
        skip_serializing_if = "Option::is_none",
        serialize_with = "crate::responses::serialize_opt_flag_yes_no"
    )]
    pub talk_detection: Option<bool>,
    /// When set to YES, the system will place a jitter buffer on the caller's
    /// audio stream before any audio mixing is performed (yes/no).
    #[serde(
        skip_serializing_if = "Option::is_none",
        serialize_with = "crate::responses::serialize_opt_flag_yes_no"
    )]
    pub jitter_buffer: Option<bool>,
}

/// \- Updates the Billing Plan from a specific DID.
///
/// Parameters for [`Client::set_did_billing_type`] (wire method `setDIDBillingType`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct SetDIDBillingTypeParams {
    /// DID affected by the new billing plan (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub did: Option<String>,
    /// Billing type for the DID (1 = Per Minute, 2 = Flat) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub billing_type: Option<DidBillingType>,
}

/// \- Updates the information from a specific DID.
///
/// Parameters for [`Client::set_did_info`] (wire method `setDIDInfo`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct SetDIDInfoParams {
    /// DID to be Updated (Example: 5551234567) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub did: Option<String>,
    /// Main Routing for the DID (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub routing: Option<crate::Routing>,
    /// Busy Routing for the DID
    #[serde(skip_serializing_if = "Option::is_none")]
    pub failover_busy: Option<crate::Routing>,
    /// Unreachable Routing for the DID
    #[serde(skip_serializing_if = "Option::is_none")]
    pub failover_unreachable: Option<crate::Routing>,
    /// NoAnswer Routing for the DID
    #[serde(skip_serializing_if = "Option::is_none")]
    pub failover_noanswer: Option<crate::Routing>,
    /// Voicemail for the DID
    #[serde(skip_serializing_if = "Option::is_none")]
    pub voicemail: Option<String>,
    /// Point of Presence for the DID ("server_pop" values from getServersInfo.
    /// Example: 3) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pop: Option<u64>,
    /// Dial Time Out for the DID (Example: 60 -> in seconds) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub dialtime: Option<u64>,
    /// CNAM for the DID (Boolean: 1/0) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cnam: Option<u64>,
    /// Caller ID Prefix for the DID
    #[serde(skip_serializing_if = "Option::is_none")]
    pub callerid_prefix: Option<String>,
    /// Note for the DID
    #[serde(skip_serializing_if = "Option::is_none")]
    pub note: Option<String>,
    /// Port Out PIN protection is used as a means of authorizing outgoing
    /// portability (only for selected US numbers with the lock icon)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub port_out_pin: Option<u64>,
    /// Billing type for the DID (1 = Per Minute, 2 = Flat) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub billing_type: Option<DidBillingType>,
    /// Record Calls (Boolean: 1/0)
    #[serde(
        skip_serializing_if = "Option::is_none",
        serialize_with = "crate::responses::serialize_opt_flag_01"
    )]
    pub record_calls: Option<bool>,
    /// Enable Call Transcription (Boolean: 1/0)
    #[serde(
        skip_serializing_if = "Option::is_none",
        serialize_with = "crate::responses::serialize_opt_flag_01"
    )]
    pub transcribe: Option<bool>,
    /// Transcription locale code (values from getLocales, comma separated for
    /// more than one locale up to 10 locales)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub transcription_locale: Option<String>,
    /// Call Transcription Email
    #[serde(skip_serializing_if = "Option::is_none")]
    pub transcription_email: Option<String>,
    /// Call Transcription Delay Seconds between 0 and 60, Increments of 5
    /// (Example: 10 -> seconds)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub transcription_start_delay: Option<u64>,
    /// Voicemail Threshold Seconds between 0 and 60, Increments of 5 (Example:
    /// 10 -> seconds) routing, failover_busy, failover_unreachable and
    /// failover_noanswer can receive values in the following format =>
    /// header:record_id Where header could be: account, fwd, vm, sip, grp, ivr,
    /// sys, recording, queue, cb, tc, disa, none. Examples: account Used for
    /// routing calls to Sub Accounts You can get all sub accounts using the
    /// getSubAccounts function fwd Used for routing calls to Forwarding
    /// entries. You can get the ID right after creating a Forwarding with
    /// setForwarding or by requesting all forwardings entries with
    /// getForwardings. vm Used for routing calls to a Voicemail. You can get
    /// all voicemails and their IDs using the getVoicemails function sys System
    /// Options: hangup = Hangup the Call busy = Busy tone noservice = System
    /// Recording: Number not in service disconnected = System Recording: Number
    /// has been disconnected dtmf = DTMF Test echo = Sound Quality Test none
    /// Used to route calls to no action Examples: 'account:100001_VoIP'
    /// 'fwd:1026' 'vm:101' 'none:' 'sys:echo'
    #[serde(skip_serializing_if = "Option::is_none")]
    pub voicemail_threshold: Option<u64>,
}

/// \- Updates the POP from a specific DID.
///
/// Parameters for [`Client::set_did_pop`] (wire method `setDIDPOP`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct SetDIDPOPParams {
    /// DID to be Updated (Example: 5551234567) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub did: Option<String>,
    /// Point of Presence for the DID ("server_pop" values from getServersInfo.
    /// Example: 3) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pop: Option<u64>,
}

/// \- Updates the Routing from a specific DID.
///
/// Parameters for [`Client::set_did_routing`] (wire method `setDIDRouting`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct SetDIDRoutingParams {
    /// DID to be Updated (Example: 5551234567) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub did: Option<String>,
    /// Main Routing for the DID routing can receive values in the following
    /// format => header:record_id Where header could be: account, fwd, vm, sip,
    /// grp, ivr, sys, recording, queue, cb, tc, disa, none. Examples: account
    /// Used for routing calls to Sub Accounts You can get all sub accounts
    /// using the getSubAccounts function fwd Used for routing calls to
    /// Forwarding entries. You can get the ID right after creating a Forwarding
    /// with setForwarding or by requesting all forwardings entries with
    /// getForwardings. vm Used for routing calls to a Voicemail. You can get
    /// all voicemails and their IDs using the getVoicemails function Examples:
    /// 'account:100001_VoIP' 'fwd:1026' 'vm:101' (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub routing: Option<crate::Routing>,
}

/// \- Updates the Voicemail from a specific DID.
///
/// Parameters for [`Client::set_did_voicemail`] (wire method `setDIDVoicemail`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct SetDIDVoicemailParams {
    /// DID to be Updated (Example: 5551234567) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub did: Option<String>,
    /// Mailbox for the DID
    #[serde(skip_serializing_if = "Option::is_none")]
    pub voicemail: Option<String>,
}

/// \- Updates a specific DISA if a disa code is provided.
/// \- Adds a new DISA entry if no disa code is provided.
///
/// Parameters for [`Client::set_disa`] (wire method `setDISA`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct SetDISAParams {
    /// ID for a specific DISA (Example: 2114 / Leave empty to create a new one)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub disa: Option<String>,
    /// Name for the DISA (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    /// Password for the DISA (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pin: Option<u64>,
    /// Time between digits (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub digit_timeout: Option<u64>,
    /// Caller ID Override for the DISA
    #[serde(skip_serializing_if = "Option::is_none")]
    pub callerid_override: Option<String>,
    /// Language for the DISA (en, fr, es)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub language: Option<String>,
}

/// \- Create or update the information of a specific "Email to Fax
/// configuration".
///
/// Parameters for [`Client::set_email_to_fax`] (wire method `setEmailToFax`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct SetEmailToFAXParams {
    /// \[Only for updates\] ID of the "Email to Fax" to edit (Values from
    /// getEmailToFax)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub id: Option<u64>,
    /// If Enable, we will send Fax Message when we receive an email from the
    /// provided address. (Values: 1=Enable / 0=Disable)
    #[serde(
        skip_serializing_if = "Option::is_none",
        serialize_with = "crate::responses::serialize_opt_flag_01"
    )]
    pub enabled: Option<bool>,
    /// Email address from you will sent Fax Messages (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub auth_email: Option<String>,
    /// Fax number that will appear as fax sender. (values from
    /// getFaxNumbersInfo) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub from_number_id: Option<String>,
    /// If Enable, we will check the mail subject if this include a Security
    /// Code before send the Fax. (Values: 1=Enable / 0=Disable)
    #[serde(
        skip_serializing_if = "Option::is_none",
        serialize_with = "crate::responses::serialize_opt_flag_01"
    )]
    pub security_code_enabled: Option<bool>,
    /// An alphanumeric code to identify your emails before send as Fax.
    /// (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub security_code: Option<String>,
    /// Set to true if testing.
    #[serde(
        skip_serializing_if = "crate::responses::is_false",
        serialize_with = "crate::responses::serialize_flag_01"
    )]
    pub test: bool,
}

/// \- Create or update the information of a specific Fax Folder.
///
/// Parameters for [`Client::set_fax_folder`] (wire method `setFaxFolder`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct SetFAXFolderParams {
    /// \[Only for updates\] ID of the Fax Folder to edit (Values from
    /// getFaxFolders)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub id: Option<u64>,
    /// Name of the Fax Folder to create or update (Example: FAMILY) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    /// Set to true if testing how to create/update a Fax Folder
    #[serde(
        skip_serializing_if = "crate::responses::is_false",
        serialize_with = "crate::responses::serialize_flag_01"
    )]
    pub test: bool,
}

/// \- Updates the email configuration from a specific Fax Number.
///
/// Parameters for [`Client::set_fax_number_email`] (wire method `setFaxNumberEmail`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct SetFAXNumberEmailParams {
    /// DID Number to be ported into our network (Example: 5552341234)
    /// (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub did: Option<String>,
    /// Email address where send notifications when receive Fax Messages -
    /// (Example: \[email protected\])
    #[serde(skip_serializing_if = "Option::is_none")]
    pub email: Option<String>,
    /// Flag to enable the email notifications. - (Values: 1 = true, 0 = false)
    /// \- Default: 0
    #[serde(
        skip_serializing_if = "Option::is_none",
        serialize_with = "crate::responses::serialize_opt_flag_01"
    )]
    pub email_enable: Option<bool>,
    /// Flag to enable attach the Fax Message as a PDF file in the
    /// notifications. - (Values: 1 = true, 0 = false) - Default: 0
    #[serde(
        skip_serializing_if = "Option::is_none",
        serialize_with = "crate::responses::serialize_opt_flag_01"
    )]
    pub email_attach_file: Option<bool>,
    /// Set to true if testing how to set the email of a Fax Number
    #[serde(
        skip_serializing_if = "crate::responses::is_false",
        serialize_with = "crate::responses::serialize_flag_01"
    )]
    pub test: bool,
}

/// \- Updates the information from a specific Fax Number.
///
/// Parameters for [`Client::set_fax_number_info`] (wire method `setFaxNumberInfo`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct SetFAXNumberInfoParams {
    /// DID Number to be ported into our network (Example: 5552341234)
    /// (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub did: Option<String>,
    /// Email address where send notifications when receive Fax Messages -
    /// (Example: \[email protected\])
    #[serde(skip_serializing_if = "Option::is_none")]
    pub email: Option<String>,
    /// Flag to enable the email notifications. - (Values: 1 = true, 0 = false)
    /// \- Default: 0
    #[serde(
        skip_serializing_if = "Option::is_none",
        serialize_with = "crate::responses::serialize_opt_flag_01"
    )]
    pub email_enable: Option<bool>,
    /// Flag to enable attach the Fax Message as a PDF file in the
    /// notifications. - (Values: 1 = true, 0 = false) - Default: 0
    #[serde(
        skip_serializing_if = "Option::is_none",
        serialize_with = "crate::responses::serialize_opt_flag_01"
    )]
    pub email_attach_file: Option<bool>,
    /// URL where make a POST when you receive a Fax Message.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub url_callback: Option<String>,
    /// Flag to enable the URL Callback functionality. - (Values: 1 = true, 0 =
    /// false) - Default: 0
    #[serde(
        skip_serializing_if = "Option::is_none",
        serialize_with = "crate::responses::serialize_opt_flag_01"
    )]
    pub url_callback_enable: Option<bool>,
    /// Flag to enable retry the POST action in case we don't receive "ok".
    #[serde(
        skip_serializing_if = "Option::is_none",
        serialize_with = "crate::responses::serialize_opt_flag_01"
    )]
    pub url_callback_retry: Option<bool>,
    /// Set to true if testing how to update the information of a Fax Number
    #[serde(
        skip_serializing_if = "crate::responses::is_false",
        serialize_with = "crate::responses::serialize_flag_01"
    )]
    pub test: bool,
}

/// \- Updates the url callback configuration from a specific Fax Number.
///
/// Parameters for [`Client::set_fax_number_url_callback`] (wire method `setFaxNumberURLCallback`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct SetFAXNumberURLCallbackParams {
    /// DID Number to be ported into our network (Example: 5552341234)
    /// (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub did: Option<String>,
    /// URL where make a POST when you receive a Fax Message.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub url_callback: Option<String>,
    /// Flag to enable the URL Callback functionality. - (Values: 1 = true, 0 =
    /// false) - Default: 0
    #[serde(
        skip_serializing_if = "Option::is_none",
        serialize_with = "crate::responses::serialize_opt_flag_01"
    )]
    pub url_callback_enable: Option<bool>,
    /// Flag to enable retry the POST action in case we don't receive "ok".
    #[serde(
        skip_serializing_if = "Option::is_none",
        serialize_with = "crate::responses::serialize_opt_flag_01"
    )]
    pub url_callback_retry: Option<bool>,
    /// Set to true if testing how to set the URL callback of a Fax Number
    #[serde(
        skip_serializing_if = "crate::responses::is_false",
        serialize_with = "crate::responses::serialize_flag_01"
    )]
    pub test: bool,
}

/// \- Updates a specific Forwarding if a fwd code is provided.
/// \- Adds a new Forwarding entry if no fwd code is provided.
///
/// Parameters for [`Client::set_forwarding`] (wire method `setForwarding`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct SetForwardingParams {
    /// ID for a specific Forwarding (Example: 19183 / Leave empty to create a
    /// new one)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub forwarding: Option<String>,
    /// Phone Number for the Forwarding (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub phone_number: Option<String>,
    /// Caller ID Override for the Forwarding
    #[serde(skip_serializing_if = "Option::is_none")]
    pub callerid_override: Option<String>,
    /// Description for the Forwarding
    #[serde(skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    /// Send DTMF digits when call is answered
    #[serde(skip_serializing_if = "Option::is_none")]
    pub dtmf_digits: Option<String>,
    /// Pause (seconds) when call is answered before sending digits (Example:
    /// 1.5 / Values: 0 to 10 in increments of 0.5)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pause: Option<String>,
    /// If enabled, we will add a Diversion Header to your forwarded call
    #[serde(
        skip_serializing_if = "Option::is_none",
        serialize_with = "crate::responses::serialize_opt_flag_01"
    )]
    pub diversion_header: Option<bool>,
}

/// \- Updates a specific IVR if an IVR code is provided.
/// \- Adds a new IVR entry if no IVR code is provided.
///
/// Parameters for [`Client::set_ivr`] (wire method `setIVR`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct SetIVRParams {
    /// ID for a specific IVR (Example: 4636 / Leave empty to create a new one)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ivr: Option<String>,
    /// Name for the IVR (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    /// Recording for the IVR (values from getRecordings) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub recording: Option<u64>,
    /// Maximum time for type in a choice after recording (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub timeout: Option<u64>,
    /// Language for the IVR (values from getLanguages) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub language: Option<String>,
    /// Voicemail Setup for the IVR (values from getVoicemailSetups) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub voicemailsetup: Option<u64>,
    /// Choices for the IVR (Example: '1=sip:5096 ; 2=fwd:20222') (required)
    #[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 {
    /// Internal Extension Location name (Example: "Location1") (required)
    #[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 {
    /// Music on Hold Name (Values from getMusicOnHold)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    /// Music on Hold Description (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    /// Music on Hold Quiet Volume (Boolean: 1/0)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub volume: Option<String>,
    /// Selected recordings sort mode (Example: "alpha", "random")
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sort: Option<RecordingSort>,
    /// Selected recordings separated by commas (Values from getRecordings,
    /// example: (1234,1235,1236) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub recordings: Option<String>,
}

/// \- Updates a specific Phonebook entry if a phonebook code is provided.
/// \- Adds a new Phonebook entry if no phonebook code is provided.
///
/// Parameters for [`Client::set_phonebook`] (wire method `setPhonebook`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct SetPhonebookParams {
    /// ID for a specific Phonebook entry (Example: 32207 / Leave empty to
    /// create a new one)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub phonebook: Option<String>,
    /// Speed Dial for the Phonebook entry
    #[serde(skip_serializing_if = "Option::is_none")]
    pub speed_dial: Option<String>,
    /// Name for the Phonebook Entry (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    /// Number or SIP for the Phonebook entry (Example: 'sip:2563' or
    /// '5552223333') (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub number: Option<String>,
    /// Caller ID Override when dialing via Speed Dial
    #[serde(skip_serializing_if = "Option::is_none")]
    pub callerid: Option<String>,
    /// Note for the phonebook entry
    #[serde(skip_serializing_if = "Option::is_none")]
    pub note: Option<String>,
    /// ID for a specific Phonebook group
    #[serde(skip_serializing_if = "Option::is_none")]
    pub group: Option<u64>,
}

/// \- Updates a specific Phonebook group if a phonebook code is provided.
/// \- Adds a new Phonebook group if no phonebook group code is provided.
/// \- Assigns or modifies group members if a member list is provided
///
/// 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>,
    /// ID for a specific Phonebook group (Example: 32207 / Leave empty to
    /// create a new one)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub group: Option<String>,
    /// Name for the Phonebook group (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    /// Phonebook entry codes associated to this group separated by a semicolon
    #[serde(skip_serializing_if = "Option::is_none")]
    pub members: Option<String>,
}

/// \- Updates a specific Queue entry if a queue code is provided.
/// \- Adds a new Queue entry if no queue code is provided.
///
/// Parameters for [`Client::set_queue`] (wire method `setQueue`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct SetQueueParams {
    /// ID for a specific Queue entry (Example: 32208 / Leave empty to create a
    /// new one)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub queue: Option<String>,
    /// Queue entry name (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub queue_name: Option<String>,
    /// Queue entry number (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub queue_number: Option<u64>,
    /// Language Code (Values from getLanguages) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub queue_language: Option<String>,
    /// Queue Password
    #[serde(skip_serializing_if = "Option::is_none")]
    pub queue_password: Option<String>,
    /// Caller ID Prefix for queue
    #[serde(skip_serializing_if = "Option::is_none")]
    pub callerid_prefix: Option<u64>,
    /// Recording Code (Values from getRecordings or 'none')
    #[serde(skip_serializing_if = "Option::is_none")]
    pub join_announcement: Option<String>,
    /// weight/priority of queue (Values 1 to 60) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub priority_weight: Option<String>,
    /// Recording Code (Values from getRecordings or 'none')
    #[serde(skip_serializing_if = "Option::is_none")]
    pub agent_announcement: Option<String>,
    /// Report hold time to agent (Values from getReportEstimatedHoldTime)
    /// (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub report_hold_time_agent: Option<String>,
    /// Member delay when the agent is connected to the caller (Values 1 to 15
    /// in seconds or 'none')
    #[serde(skip_serializing_if = "Option::is_none")]
    pub member_delay: Option<crate::Seconds>,
    /// Ammount of time a caller can wait in queue (Values in seconds: multiples
    /// of 30, max value: 1200 or 'unlimited')
    #[serde(skip_serializing_if = "Option::is_none")]
    pub maximum_wait_time: Option<crate::WaitTime>,
    /// Maximum callers (Values: 1 to 60 or 'unlimited')
    #[serde(skip_serializing_if = "Option::is_none")]
    pub maximum_callers: Option<String>,
    /// How caller join to the queue (Values from getJoinWhenEmptyTypes)
    /// Examples: yes Callers can join a queue with no members or only
    /// unavailable members no Callers cannot join a queue with no members
    /// strict Callers cannot join a queue with no members or only unavailable
    /// members (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub join_when_empty: Option<QueueEmptyBehavior>,
    /// How caller leave the queue (Values 'yes'/'no'/'strict') Examples: yes
    /// Callers are sent to failover when there are no members no Callers will
    /// remain in the queue even if there are no members strict Callers are sent
    /// to failover if there are members but none of them is available.
    /// (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub leave_when_empty: Option<QueueEmptyBehavior>,
    /// Ring strategy (Values from getRingStrategies) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ring_strategy: Option<RingStrategy>,
    /// If you want the queue to avoid sending calls to members (Values
    /// 'yes'/'no') (required)
    #[serde(
        skip_serializing_if = "Option::is_none",
        serialize_with = "crate::responses::serialize_opt_flag_yes_no"
    )]
    pub ring_inuse: Option<bool>,
    /// Number of seconds to ring an agent (Values 5 to 60)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub agent_ring_timeout: Option<u64>,
    /// How long do we wait before trying all the members again (Values 5 to 60
    /// seconds or 'none'= No Delay)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub retry_timer: Option<crate::Seconds>,
    /// After a successful call, the number of seconds to wait before sending a
    /// free agent another call (Values 1 to 60 seconds or 'none'= No Delay)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub wrapup_time: Option<crate::Seconds>,
    /// Code for Recording (Values from getRecordings or 'none')
    #[serde(skip_serializing_if = "Option::is_none")]
    pub voice_announcement: Option<String>,
    /// Periodic interval to play voice announce recording (Values in seconds:
    /// multiples of 15, max value: 1200 or 'none' = No announcement)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub frequency_announcement: Option<crate::Seconds>,
    /// How often to make any periodic announcement (Values in seconds:
    /// multiples of 15, max value: 1200 or 'none' = No announcement)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub announce_position_frecuency: Option<crate::Seconds>,
    /// Announce seconds (Values in seconds: 1 to 60 or 'none' = Do not
    /// announce)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub announce_round_seconds: Option<crate::Seconds>,
    /// Include estimated hold time in position announcements (Values
    /// 'yes'/'no'/'once')
    #[serde(skip_serializing_if = "Option::is_none")]
    pub if_announce_position_enabled_report_estimated_hold_time: Option<EstimatedHoldTimeAnnounce>,
    /// Yes to say "Thank you for your patience" immediatly after announcing
    /// Queue Position and Estimated hold time left (Values 'yes'/'no')
    #[serde(
        skip_serializing_if = "Option::is_none",
        serialize_with = "crate::responses::serialize_opt_flag_yes_no"
    )]
    pub thankyou_for_your_patience: Option<bool>,
    /// Music on Hold Code (Values from getMusicOnHold)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub music_on_hold: Option<String>,
    /// Failover routing to Maximum wait time reached
    #[serde(skip_serializing_if = "Option::is_none")]
    pub fail_over_routing_timeout: Option<crate::Routing>,
    /// Failover routing to Maximum callers reached
    #[serde(skip_serializing_if = "Option::is_none")]
    pub fail_over_routing_full: Option<crate::Routing>,
    /// A call was sent to the queue but the queue had no members (Only works
    /// when Join when Empty is set to no)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub fail_over_routing_join_empty: Option<crate::Routing>,
    /// The last agent was removed form the queue before alls calls were handled
    /// (Only works when Leave when Empty is set to yes)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub fail_over_routing_leave_empty: Option<crate::Routing>,
    /// Same as routingjoinempty, except that there were still queue members,
    /// but all were status unavailable
    #[serde(skip_serializing_if = "Option::is_none")]
    pub fail_over_routing_join_unavail: Option<crate::Routing>,
    /// Same as routingleaveempty, except that there were still queue members,
    /// but all were status unavailable routings can receive values in the
    /// following format => header:record_id Where header could be: account,
    /// fwd, vm, sip, grp, ivr, sys, recording, queue, cb, tc, disa, none.
    /// Examples: account Used for routing calls to Sub Accounts You can get all
    /// sub accounts using the getSubAccounts function fwd Used for routing
    /// calls to Forwarding entries. You can get the ID right after creating a
    /// Forwarding with setForwarding or by requesting all forwardings entries
    /// with getForwardings. vm Used for routing calls to a Voicemail. You can
    /// get all voicemails and their IDs using the getVoicemails function
    /// Examples: 'account:100001_VoIP' 'fwd:1026' 'vm:101'
    #[serde(skip_serializing_if = "Option::is_none")]
    pub fail_over_routing_leave_unavail: Option<crate::Routing>,
}

/// \- Updates a specific Recording File if a Recording ID is provided.
/// \- Adds a new Recording file entry if no Recording ID is provided.
///
/// Parameters for [`Client::set_recording`] (wire method `setRecording`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct SetRecordingParams {
    /// ID for a specific Phonebook entry (Example: 33221 / Leave empty to
    /// create a new one)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub recording: Option<String>,
    /// Base64 encoded file (Provide Recording ID and file if you want update
    /// the file only) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub file: Option<String>,
    /// Name for the Recording Entry (Example: 'recording1') (Provide Recording
    /// ID and name if you want update the name only) (Provide Recording ID,
    /// file and name if you want update both parameters at the same time)
    /// (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
}

/// \- Updates a specific Ring Group if a ring group code is provided.
/// \- Adds a new Ring Group entry if no ring group code is provided.
///
/// Parameters for [`Client::set_ring_group`] (wire method `setRingGroup`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct SetRingGroupParams {
    /// ID for a specific Ring Group (Example: 4768 / Leave empty to create a
    /// new one)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ring_group: Option<String>,
    /// Name for the Ring Group (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    /// Members for the Ring Group (Example: 'account:100001;fwd:16006')
    /// (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub members: Option<String>,
    /// Voicemail for the Ring Group (Values from getVoicemails) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub voicemail: Option<String>,
    /// Recording Code (Values from getRecordings)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub caller_announcement: Option<String>,
    /// Music on Hold Code (Values from getMusicOnHold)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub music_on_hold: Option<String>,
    /// Code for Language (Values from getLanguages) "members" can receive the
    /// following routing headers: account Used to route the call to an Account
    /// or a Sub Account fwd Used to route the call to a Forwarding entry sip
    /// Used to route the call to a SIP URI Each member can a specific ring time
    /// and press1 values, you can add those to the routing header as follow:
    /// Example: 'account:100001,25,0;fwd:16006,10,1' 25 = Default ring time
    /// value (Values from 1 to 60 sec) 0 = Default press1 value (Values allowed
    /// 0 and 1)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub language: Option<String>,
}

/// \- Updates a specific SIP URI if a SIP URI code is provided.
/// \- Adds a new SIP URI entry if no SIP URI code is provided.
///
/// Parameters for [`Client::set_sip_uri`] (wire method `setSIPURI`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct SetSIPURIParams {
    /// ID for a specific SIP URI (Example: 6199 / Leave empty to create a new
    /// one)
    #[serde(skip_serializing_if = "Option::is_none", rename = "sipuri")]
    pub sip_uri: Option<String>,
    /// SIP URI (Example: '\[email protected\]') (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub uri: Option<String>,
    /// Description for the SIP URI
    #[serde(skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    /// This setting is optional. You can configure a 'CallerID Number
    /// Override'. Your default CallerID number will be changed to the override
    /// you have configured here when using this SIP URI.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub callerid_override: Option<String>,
    /// If this option is Enabled, then your CallerID will be E164 compliant.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub callerid_e164: Option<u64>,
}

/// \- Enable/Disable the SMS Service for a DID
/// \- Change the SMS settings for a DID
///
/// Parameters for [`Client::set_sms`] (wire method `setSMS`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct SetSMSParams {
    /// DID to be Updated (Example: 5551234567) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub did: Option<String>,
    /// Enable/Disable the DID to receive SMS Messages (Values: 1=Enable /
    /// 0=Disable) (required)
    #[serde(
        skip_serializing_if = "Option::is_none",
        serialize_with = "crate::responses::serialize_opt_flag_01"
    )]
    pub enable: Option<bool>,
    /// If Enable, SMS Messages received by your DID will be sent to the email
    /// address provided (Values: 1=Enable / 0=Disable)
    #[serde(
        skip_serializing_if = "Option::is_none",
        serialize_with = "crate::responses::serialize_opt_flag_01"
    )]
    pub email_enabled: Option<bool>,
    /// SMS Messages received by your DID will be sent to the email address
    /// provided
    #[serde(skip_serializing_if = "Option::is_none")]
    pub email_address: Option<String>,
    /// If Enable, SMS Messages received by your DID will be forwarded to the
    /// phone number provided (Values: 1=Enable / 0=Disable)
    #[serde(
        skip_serializing_if = "Option::is_none",
        serialize_with = "crate::responses::serialize_opt_flag_01"
    )]
    pub sms_forward_enable: Option<bool>,
    /// SMS Messages received by your DID will be forwarded to the phone number
    /// provided (Example: 5551234567)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sms_forward: Option<String>,
    /// If Enable, SMS Messages received by your DID will be send a GET request
    /// to the URL callback provided (Values: 1=Enable / 0=Disable)
    #[serde(
        skip_serializing_if = "Option::is_none",
        serialize_with = "crate::responses::serialize_opt_flag_01"
    )]
    pub url_callback_enable: Option<bool>,
    /// SMS Messages received by your DID will be send a GET request to the URL
    /// callback provided Available Variables for your URL {FROM} The phone
    /// number that sent you the message. {TO} The DID number that received the
    /// message. {MESSAGE} The content of the message. Example:
    /// <http://mysite.com/sms.php?to={TO}&from={FROM}&message={MESSAGE}>
    #[serde(skip_serializing_if = "Option::is_none")]
    pub url_callback: Option<String>,
    /// Enable URL callback Retry (Values: 1=Enable / 0=Disable) we will be
    /// expecting an 'ok' output (without quotes) from your URL callback page as
    /// an indicator that you have received the message correctly. If we don't
    /// receive the 'ok' letters (wihtout quotes) from your callback page, we
    /// will keep sending you the same message every 30 minutes.
    #[serde(
        skip_serializing_if = "Option::is_none",
        serialize_with = "crate::responses::serialize_opt_flag_01"
    )]
    pub url_callback_retry: Option<bool>,
    /// SIP account or sub-account that will receive the SMS Messages
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sms_sipaccount: Option<String>,
    /// If Enable, SMS Messages received by your DID will be sent to the
    /// specified SIP account or sub-account (Values: 1=Enable / 0=Disable)
    #[serde(
        skip_serializing_if = "Option::is_none",
        serialize_with = "crate::responses::serialize_opt_flag_01"
    )]
    pub sms_sipaccount_enabled: Option<bool>,
}

/// \- Updates a specific Member from queue if a Member code is provided.
/// \- Adds a new Member to Queue if no Member code is provided.
///
/// Parameters for [`Client::set_static_member`] (wire method `setStaticMember`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct SetStaticMemberParams {
    /// ID for a specific Member (Example: 619 / Leave empty to create a new
    /// one)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub member: Option<String>,
    /// ID for a specific Queue (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub queue: Option<u64>,
    /// Member Description (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub member_name: Option<String>,
    /// Static Member Routing to receive calls - You can get all sub accounts
    /// using the getSubAccounts function
    #[serde(skip_serializing_if = "Option::is_none")]
    pub account: Option<String>,
    /// Values for get calls first (Example: 0) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub priority: Option<u64>,
}

/// \- Updates Sub Account information.
///
/// Parameters for [`Client::set_sub_account`] (wire method `setSubAccount`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct SetSubAccountParams {
    /// Sub Account ID (Example: 10236) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub id: Option<u64>,
    /// Sub Account Description (Example: 'VoIP Account')
    #[serde(skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    /// Authorization Type Code (Values from getAuthTypes) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub auth_type: Option<u64>,
    /// Sub Account Password (For Password Authentication)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub password: Option<String>,
    /// Sub Account IP (For IP Authentication)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ip: Option<String>,
    /// Device Type Code (Values from getDeviceTypes) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub device_type: Option<u64>,
    /// Caller ID Override
    #[serde(skip_serializing_if = "Option::is_none")]
    pub callerid_number: Option<String>,
    /// Route Code (Values from getRoutes)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub canada_routing: Option<String>,
    /// Lock International Code (Values from getLockInternational) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lock_international: Option<u64>,
    /// Route Code (Values from getRoutes) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub international_route: Option<u64>,
    /// Music on Hold Code (Values from getMusicOnHold) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub music_on_hold: Option<String>,
    /// Language for system messages, such as "Invalid Option" (Values from
    /// getLanguages)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub language: Option<String>,
    /// List of Allowed Codecs (Values from getAllowedCodecs) Codecs separated
    /// by semicolon (Example: ulaw;g729;gsm) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub allowed_codecs: Option<String>,
    /// DTMF Mode Code (Values from getDTMFModes) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub dtmf_mode: Option<DtmfMode>,
    /// NAT Mode Code (Values from getNAT) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub nat: Option<Nat>,
    /// Encrypted SIP Traffic (Boolean: 1/0)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sip_traffic: Option<u64>,
    /// Max Expiry between 60 and 3600 (Example: 3000)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max_expiry: Option<u64>,
    /// RTP Time Out between 1 and 3600 (Example: 60)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub rtp_timeout: Option<u64>,
    /// RTP Hold Time Out between 1 and 3600 (Example: 600)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub rtp_hold_timeout: Option<u64>,
    /// List of IP/Netmask to allow outgoing calls separated by commas (Example:
    /// 123.45.3.21,10.255.12.0/22,device.mydomain.com)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub ip_restriction: Option<String>,
    /// Enable IP Restriction (Boolean: 1/0)
    #[serde(
        skip_serializing_if = "Option::is_none",
        serialize_with = "crate::responses::serialize_opt_flag_01"
    )]
    pub enable_ip_restriction: Option<bool>,
    /// List of POP Servers to allow outgoing calls separated by commas (values
    /// from getServersInfo. Example: 10,23,45)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pop_restriction: Option<String>,
    /// Enable POP Restriction (Boolean: 1/0)
    #[serde(
        skip_serializing_if = "Option::is_none",
        serialize_with = "crate::responses::serialize_opt_flag_01"
    )]
    pub enable_pop_restriction: Option<bool>,
    /// Sub Account Internal Extension (Example: 1 -> Creates 101)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub internal_extension: Option<String>,
    /// Sub Account Internal Voicemail (Example: 101)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub internal_voicemail: Option<String>,
    /// Sub Account Internal Dialtime (Example: 60 -> seconds)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub internal_dialtime: Option<String>,
    /// Reseller Account ID (Example: 561115)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub reseller_client: Option<String>,
    /// Reseller Package (Example: 92364)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub reseller_package: Option<String>,
    /// Reseller Next Billing Date (Example: '2012-12-31')
    #[serde(skip_serializing_if = "Option::is_none")]
    pub reseller_nextbilling: Option<String>,
    /// True if you want to charge Package Setup Fee after Save
    #[serde(skip_serializing_if = "Option::is_none")]
    pub reseller_chargesetup: Option<String>,
    /// Send BYE on successful transfer (Boolean: 1/0)
    #[serde(
        skip_serializing_if = "Option::is_none",
        serialize_with = "crate::responses::serialize_opt_flag_01"
    )]
    pub send_bye: Option<bool>,
    /// Record Calls (Boolean: 1/0)
    #[serde(
        skip_serializing_if = "Option::is_none",
        serialize_with = "crate::responses::serialize_opt_flag_01"
    )]
    pub record_calls: Option<bool>,
    #[serde(
        skip_serializing_if = "Option::is_none",
        serialize_with = "crate::responses::serialize_opt_flag_01"
    )]
    pub transcribe: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub transcription_locale: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub transcription_email: Option<String>,
    /// Call Transcription Delay Seconds between 0 and 60, Increments of 5
    /// (Example: 10 -> seconds)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub transcription_start_delay: Option<u64>,
    /// Allows you to dial outgoing calls using either the NANPA configuration
    /// or the E164 configuration. (Values: 0 = Use Main Account Setting, 1 =
    /// E164, 2 = NANPA)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub dialing_mode: Option<DialingMode>,
    /// This allows you to select the carrier to be used for outgoing calls to
    /// toll-free numbers. (Values: -1 = Use main account settings, 0 = Default
    /// server setting, 1 = US carrier, 2 = Canadian carrier)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tfcarrier: Option<TollFreeCarrier>,
    /// Location group for the internal extension (Values from getLocations)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub internal_extension_location: Option<u64>,
    /// e911 Default CallerID
    #[serde(skip_serializing_if = "Option::is_none")]
    pub default_e911: Option<String>,
}

/// \- Updates a specific Time Condition if a time condition code is provided.
/// \- Adds a new Time Condition entry if no time condition code is provided.
///
/// Parameters for [`Client::set_time_condition`] (wire method `setTimeCondition`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct SetTimeConditionParams {
    /// ID for a specific Time Condition (Example: 1830 / Leave empty to create
    /// a new one)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub timecondition: Option<String>,
    /// Name for the Time Condition (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    /// Routing for the Call when condition matches (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub routing_match: Option<crate::Routing>,
    /// Routing for the Call when condition does not matche (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub routing_nomatch: Option<crate::Routing>,
    /// All the Start Hour Conditions (Example: '8;8') (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub starthour: Option<String>,
    /// All the Start Minute Conditions (Example: '0;0') (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub startminute: Option<String>,
    /// All the End Hour Conditions (Example: '16;12') (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub endhour: Option<String>,
    /// All the End Minute Conditions (Example: '0;0') (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub endminute: Option<String>,
    /// All the Week Day Start Conditions (Example: 'mon;sat') (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub weekdaystart: Option<String>,
    /// All the Week Day End Conditions (Example: 'fri;sat') (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub weekdayend: Option<String>,
}

/// \- Updates the information from a specific Voicemail.
///
/// Parameters for [`Client::set_voicemail`] (wire method `setVoicemail`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct SetVoicemailParams {
    /// ID for a specific Mailbox (Example: 1001) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub mailbox: Option<u64>,
    /// Name for the Mailbox (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    /// Password for the Mailbox (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub password: Option<String>,
    /// True if Skipping Password (Boolean: 1/0) (required)
    #[serde(
        skip_serializing_if = "Option::is_none",
        serialize_with = "crate::responses::serialize_opt_flag_01"
    )]
    pub skip_password: Option<bool>,
    /// Email address for receiving messages, multiple email addresses are
    /// allowed if separated by a comma
    #[serde(skip_serializing_if = "Option::is_none")]
    pub email: Option<String>,
    /// Yes for Attaching WAV files to Message (Values: 'yes'/'no') (required)
    #[serde(
        skip_serializing_if = "Option::is_none",
        serialize_with = "crate::responses::serialize_opt_flag_yes_no"
    )]
    pub attach_message: Option<bool>,
    /// Yes for Deleting Messages (Values: 'yes'/'no') (required)
    #[serde(
        skip_serializing_if = "Option::is_none",
        serialize_with = "crate::responses::serialize_opt_flag_yes_no"
    )]
    pub delete_message: Option<bool>,
    /// Yes for Saying Time Stamp (Values: 'yes'/'no') (required)
    #[serde(
        skip_serializing_if = "Option::is_none",
        serialize_with = "crate::responses::serialize_opt_flag_yes_no"
    )]
    pub say_time: Option<bool>,
    /// Time Zone for Mailbox (Values from getTimeZones) (required)
    #[serde(
        skip_serializing_if = "Option::is_none",
        serialize_with = "crate::responses::serialize_opt_tz"
    )]
    pub timezone: Option<chrono_tz::Tz>,
    /// Yes for Saying the Caller ID (Values: 'yes'/'no') (required)
    #[serde(
        skip_serializing_if = "Option::is_none",
        serialize_with = "crate::responses::serialize_opt_flag_yes_no"
    )]
    pub say_callerid: Option<bool>,
    /// Code for Play Instructions Setting (Values from getPlayInstructions)
    /// (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub play_instructions: Option<PlayInstructions>,
    /// Code for Language (Values from getLanguages) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub language: Option<String>,
    /// Code for Email Attachment format (Values from
    /// getVoicemailAttachmentFormats)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub email_attachment_format: Option<EmailAttachmentFormat>,
    /// Recording for the Unavailable Message (values from getRecordings)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub unavailable_message_recording: Option<String>,
    /// 'yes' to enable Voicemail Transcription
    #[serde(
        skip_serializing_if = "Option::is_none",
        serialize_with = "crate::responses::serialize_opt_flag_yes_no"
    )]
    pub transcription: Option<bool>,
    /// Transcription locale code (values from getLocales, comma separated for
    /// more than one locale up to 10 locales)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub transcription_locale: Option<String>,
    /// Yes for Transcription redaction (Values: 'yes'/'no')
    #[serde(
        skip_serializing_if = "Option::is_none",
        serialize_with = "crate::responses::serialize_opt_flag_yes_no"
    )]
    pub transcription_redaction: Option<bool>,
    /// Yes for Transcription sentiment (Values: 'yes'/'no')
    #[serde(
        skip_serializing_if = "Option::is_none",
        serialize_with = "crate::responses::serialize_opt_flag_yes_no"
    )]
    pub transcription_sentiment: Option<bool>,
    /// Yes for Transcription summary (Values: 'yes'/'no')
    #[serde(
        skip_serializing_if = "Option::is_none",
        serialize_with = "crate::responses::serialize_opt_flag_yes_no"
    )]
    pub transcription_summary: Option<bool>,
    /// Transcription format ( Values: 'html'/'text')
    #[serde(skip_serializing_if = "Option::is_none")]
    pub transcription_format: Option<TranscriptionFormat>,
}

/// \- Signs a new Reseller Client to your Reseller Account.
///
/// Parameters for [`Client::signup_client`] (wire method `signupClient`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct SignupClientParams {
    /// Client's Firstname (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub firstname: Option<String>,
    /// Client's Lastname (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lastname: Option<String>,
    /// Client's Company
    #[serde(skip_serializing_if = "Option::is_none")]
    pub company: Option<String>,
    /// Client's Address (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub address: Option<String>,
    /// Client's City (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub city: Option<String>,
    /// Client's State (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub state: Option<String>,
    /// Client's Country (Values from getCountries) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub country: Option<String>,
    /// Client's Zip Code (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub zip: Option<String>,
    /// Client's Phone Number (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub phone_number: Option<String>,
    /// Client's e-mail (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub email: Option<String>,
    /// Client's Confirmation e-mail (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub confirm_email: Option<String>,
    /// Client's Password (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub password: Option<String>,
    /// Client's Confirmation Password (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub confirm_password: Option<String>,
    /// Activates Client (Boolean: 1/0)
    #[serde(
        skip_serializing_if = "Option::is_none",
        serialize_with = "crate::responses::serialize_opt_flag_01"
    )]
    pub activate: Option<bool>,
    /// Balance Management for Client (Values from getBalanceManagement)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub balance_management: Option<u64>,
}

/// \- Unconnects specific DID from Reseller Client Sub Account.
///
/// Parameters for [`Client::unconnect_did`] (wire method `unconnectDID`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct UnconnectDIDParams {
    /// DID to be Unconnected from Reseller Sub Account(Example: 5551234567)
    /// (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub did: Option<String>,
}

/// \- Unconnects specific FAX DID from Reseller Client Sub Account.
///
/// Parameters for [`Client::unconnect_fax`] (wire method `unconnectFAX`).
#[derive(Debug, Default, Clone, Serialize)]
pub struct UnconnectFAXParams {
    /// FAX DID to be Unconnected from Reseller Sub Account (Example:
    /// 5551234567) (required)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub did: Option<String>,
}

/// Response body for [`Client::add_charge`] (wire method `addCharge`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct AddChargeResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
}

/// Response body for [`Client::add_lnp_file`] (wire method `addLNPFile`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct AddLNPFileResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub attachment: Option<String>,
}

/// Response body for [`Client::add_lnp_port`] (wire method `addLNPPort`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct AddLNPPortResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub port: Option<String>,
}

/// Response body for [`Client::add_member_to_conference`] (wire method `addMemberToConference`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct AddMemberToConferenceResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub member: Option<u64>,
}

/// Response body for [`Client::add_payment`] (wire method `addPayment`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct AddPaymentResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
}

/// Response body for [`Client::assign_did_vpri`] (wire method `assignDIDvPRI`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct AssignDIDvPRIResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub vpri: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool",
        rename = "DIDAdded"
    )]
    pub did_added: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_decimal_from_string_or_number"
    )]
    pub monthly: Option<rust_decimal::Decimal>,
}

/// Response body for [`Client::back_order_did_can`] (wire method `backOrderDIDCAN`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct BackOrderDIDCANResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
}

/// Response body for [`Client::back_order_did_usa`] (wire method `backOrderDIDUSA`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct BackOrderDIDUSAResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
}

/// Response body for [`Client::cancel_did`] (wire method `cancelDID`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct CancelDIDResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
}

/// Response body for [`Client::cancel_fax_number`] (wire method `cancelFaxNumber`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct CancelFAXNumberResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub deleted_did: Option<String>,
}

/// Response body for [`Client::connect_did`] (wire method `connectDID`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct ConnectDIDResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
}

/// Response body for [`Client::connect_fax`] (wire method `connectFAX`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct ConnectFAXResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
}

/// Response body for [`Client::create_sub_account`] (wire method `createSubAccount`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct CreateSubAccountResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub id: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub account: Option<String>,
}

/// Response body for [`Client::create_voicemail`] (wire method `createVoicemail`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct CreateVoicemailResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
}

/// Response body for [`Client::del_call_hunting`] (wire method `delCallHunting`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct DelCallHuntingResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
}

/// Response body for [`Client::del_call_parking`] (wire method `delCallParking`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct DelCallParkingResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
}

/// Response body for [`Client::del_call_recording`] (wire method `delCallRecording`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct DelCallRecordingResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
}

/// Response body for [`Client::del_callback`] (wire method `delCallback`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct DelCallbackResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
}

/// Response body for [`Client::del_caller_id_filtering`] (wire method `delCallerIDFiltering`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct DelCallerIDFilteringResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
}

/// Response body for [`Client::del_client`] (wire method `delClient`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct DelClientResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
}

/// Response body for [`Client::del_conference`] (wire method `delConference`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct DelConferenceResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
}

/// Response body for [`Client::del_conference_member`] (wire method `delConferenceMember`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct DelConferenceMemberResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
}

/// Response body for [`Client::del_disa`] (wire method `delDISA`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct DelDISAResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
}

/// Response body for [`Client::del_email_to_fax`] (wire method `delEmailToFax`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct DelEmailToFAXResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
}

/// Response body for [`Client::del_fax_folder`] (wire method `delFaxFolder`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct DelFAXFolderResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
}

/// Response body for [`Client::del_forwarding`] (wire method `delForwarding`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct DelForwardingResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
}

/// Response body for [`Client::del_ivr`] (wire method `delIVR`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct DelIVRResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
}

/// Response body for [`Client::del_location`] (wire method `delLocation`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct DelLocationResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
}

/// Response body for [`Client::del_member_from_conference`] (wire method `delMemberFromConference`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct DelMemberFromConferenceResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
}

/// Response body for [`Client::del_messages`] (wire method `delMessages`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct DelMessagesResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
}

/// Response body for [`Client::del_music_on_hold`] (wire method `delMusicOnHold`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct DelMusicOnHoldResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
}

/// Response body for [`Client::del_phonebook`] (wire method `delPhonebook`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct DelPhonebookResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
}

/// Response body for [`Client::del_phonebook_group`] (wire method `delPhonebookGroup`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct DelPhonebookGroupResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
}

/// Response body for [`Client::del_queue`] (wire method `delQueue`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct DelQueueResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
}

/// Response body for [`Client::del_recording`] (wire method `delRecording`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct DelRecordingResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
}

/// Response body for [`Client::del_ring_group`] (wire method `delRingGroup`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct DelRingGroupResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
}

/// Response body for [`Client::del_sip_uri`] (wire method `delSIPURI`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct DelSIPURIResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
}

/// Response body for [`Client::del_static_member`] (wire method `delStaticMember`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct DelStaticMemberResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
}

/// Response body for [`Client::del_sub_account`] (wire method `delSubAccount`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct DelSubAccountResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
}

/// Response body for [`Client::del_time_condition`] (wire method `delTimeCondition`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct DelTimeConditionResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
}

/// Response body for [`Client::del_voicemail`] (wire method `delVoicemail`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct DelVoicemailResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
}

/// Response body for [`Client::delete_fax_message`] (wire method `deleteFaxMessage`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct DeleteFAXMessageResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
}

/// Response body for [`Client::delete_mms`] (wire method `deleteMMS`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct DeleteMMSResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
}

/// Response body for [`Client::delete_sms`] (wire method `deleteSMS`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct DeleteSMSResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
}

/// Response body for [`Client::e911_address_types`] (wire method `e911AddressTypes`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct E911AddressTypesResponseType {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub value: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub description: Option<String>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct E911AddressTypesResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub types: Vec<E911AddressTypesResponseType>,
}

/// Response body for [`Client::e911_cancel`] (wire method `e911Cancel`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct E911CancelResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
}

/// Response body for [`Client::e911_info`] (wire method `e911Info`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct E911InfoResponseInfo {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub did: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub full_name: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub street_number: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub street_name: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub address_type: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub address_number: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub city: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub state: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub zip_code: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub country: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub language: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub email: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub other_info: Option<String>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct E911InfoResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(default)]
    pub info: Option<E911InfoResponseInfo>,
}

/// Response body for [`Client::e911_provision`] (wire method `e911Provision`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct E911ProvisionResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
}

/// Response body for [`Client::e911_provision_manually`] (wire method `e911ProvisionManually`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct E911ProvisionManuallyResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
}

/// Response body for [`Client::e911_update`] (wire method `e911Update`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct E911UpdateResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
}

/// Response body for [`Client::e911_validate`] (wire method `e911Validate`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct E911ValidateResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
}

/// Response body for [`Client::get_allowed_codecs`] (wire method `getAllowedCodecs`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetAllowedCodecsResponseAllowedCodec {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub value: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub description: Option<String>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetAllowedCodecsResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub allowed_codecs: Vec<GetAllowedCodecsResponseAllowedCodec>,
}

/// Response body for [`Client::get_auth_types`] (wire method `getAuthTypes`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetAuthTypesResponseAuthType {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub value: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub description: Option<String>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetAuthTypesResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub auth_types: Vec<GetAuthTypesResponseAuthType>,
}

/// Response body for [`Client::get_back_orders`] (wire method `getBackOrders`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetBackOrdersResponseBackOrder {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub id: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub description: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_routing"
    )]
    pub routing: Option<crate::Routing>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_routing"
    )]
    pub failover_busy: Option<crate::Routing>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_routing"
    )]
    pub failover_unreachable: Option<crate::Routing>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_routing"
    )]
    pub failover_noanswer: Option<crate::Routing>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub voicemail: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub pop: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub dialtime: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub cnam: Option<u64>,
    #[serde(default, deserialize_with = "deserialize_opt_did_billing_type")]
    pub billing_type: Option<DidBillingType>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_datetime"
    )]
    pub order_date: Option<chrono::NaiveDateTime>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetBackOrdersResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub quantity: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub back_orders: Vec<GetBackOrdersResponseBackOrder>,
}

/// Response body for [`Client::get_balance`] (wire method `getBalance`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetBalanceResponseBalance {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_decimal_from_string_or_number"
    )]
    pub current_balance: Option<rust_decimal::Decimal>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_decimal_from_string_or_number"
    )]
    pub spent_total: Option<rust_decimal::Decimal>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub calls_total: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub time_total: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_decimal_from_string_or_number"
    )]
    pub spent_today: Option<rust_decimal::Decimal>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub calls_today: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub time_today: Option<String>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetBalanceResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(default)]
    pub balance: Option<GetBalanceResponseBalance>,
}

/// Response body for [`Client::get_balance_management`] (wire method `getBalanceManagement`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetBalanceManagementResponseBalanceManagement {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub value: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub description: Option<String>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetBalanceManagementResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub balance_management: Vec<GetBalanceManagementResponseBalanceManagement>,
}

/// Response body for [`Client::get_cdr`] (wire method `getCDR`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetCDRResponseCDR {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_datetime"
    )]
    pub date: Option<chrono::NaiveDateTime>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub callerid: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub destination: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub description: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub account: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub disposition: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub duration: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub seconds: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_decimal_from_string_or_number"
    )]
    pub rate: Option<rust_decimal::Decimal>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_decimal_from_string_or_number"
    )]
    pub total: Option<rust_decimal::Decimal>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub uniqueid: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub destination_type: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub call_logs: Option<String>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetCDRResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub cdr: Vec<GetCDRResponseCDR>,
}

/// Response body for [`Client::get_call_accounts`] (wire method `getCallAccounts`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetCallAccountsResponseAccount {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub value: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub description: Option<String>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetCallAccountsResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub accounts: Vec<GetCallAccountsResponseAccount>,
}

/// Response body for [`Client::get_call_billing`] (wire method `getCallBilling`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetCallBillingResponseCallBilling {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub value: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub description: Option<String>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetCallBillingResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub call_billing: Vec<GetCallBillingResponseCallBilling>,
}

/// Response body for [`Client::get_call_huntings`] (wire method `getCallHuntings`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetCallHuntingsResponseCallHunting {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub callhunting: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub description: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub members: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub ring_time: Option<String>,
    #[serde(default, deserialize_with = "deserialize_opt_ring_group_order")]
    pub order: Option<RingGroupOrder>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub press: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub music: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub recording: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub language: Option<String>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetCallHuntingsResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub call_hunting: Vec<GetCallHuntingsResponseCallHunting>,
}

/// Response body for [`Client::get_call_parking`] (wire method `getCallParking`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetCallParkingResponseCallHunting {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub callparking: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub name: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub timeout: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub musiconhold: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub failover: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub language: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub destination: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub delay: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub blf_lamps: Option<u64>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetCallParkingResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub call_hunting: Vec<GetCallParkingResponseCallHunting>,
}

/// Response body for [`Client::get_call_recording`] (wire method `getCallRecording`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetCallRecordingResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub callrecording: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_datetime"
    )]
    pub datetime: Option<chrono::NaiveDateTime>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub destination: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub r#type: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub subaccount: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub duration: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub base64file: Option<String>,
}

/// Response body for [`Client::get_call_recordings`] (wire method `getCallRecordings`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetCallRecordingsResponseRecording {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub callrecording: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_datetime"
    )]
    pub datetime: Option<chrono::NaiveDateTime>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub destination: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub r#type: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub subaccount: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub duration: Option<String>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetCallRecordingsResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub recordings: Vec<GetCallRecordingsResponseRecording>,
}

/// Response body for [`Client::get_call_transcriptions`] (wire method `getCallTranscriptions`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetCallTranscriptionsResponseTranscriptionRecognizedPhrase {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub time: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_decimal_from_string_or_number"
    )]
    pub duration: Option<rust_decimal::Decimal>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub speaker: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub phrase: Option<String>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetCallTranscriptionsResponseTranscription {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub date: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub duration: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub speakers: Vec<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub locale: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub confidence: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub recognized_phrases: Vec<GetCallTranscriptionsResponseTranscriptionRecognizedPhrase>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetCallTranscriptionsResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub transcriptions: Vec<GetCallTranscriptionsResponseTranscription>,
}

/// Response body for [`Client::get_call_types`] (wire method `getCallTypes`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetCallTypesResponseCallType {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub value: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub description: Option<String>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetCallTypesResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub call_types: Vec<GetCallTypesResponseCallType>,
}

/// Response body for [`Client::get_callbacks`] (wire method `getCallbacks`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetCallbacksResponseCallback {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub callback: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub description: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub number: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub delay_before: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub response_timeout: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub digit_timeout: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_sentinel_none"
    )]
    pub callerid_number: Option<String>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetCallbacksResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub callbacks: Vec<GetCallbacksResponseCallback>,
}

/// Response body for [`Client::get_caller_id_filtering`] (wire method `getCallerIDFiltering`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetCallerIDFilteringResponseFiltering {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub filtering: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub callerid: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub did: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_routing"
    )]
    pub routing: Option<crate::Routing>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_routing"
    )]
    pub failover_unreachable: Option<crate::Routing>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_routing"
    )]
    pub failover_busy: Option<crate::Routing>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_routing"
    )]
    pub failover_noanswer: Option<crate::Routing>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub note: Option<String>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetCallerIDFilteringResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub filtering: Vec<GetCallerIDFilteringResponseFiltering>,
}

/// Response body for [`Client::get_carriers`] (wire method `getCarriers`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetCarriersResponseCarrier {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub value: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub description: Option<String>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetCarriersResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub carriers: Vec<GetCarriersResponseCarrier>,
}

/// Response body for [`Client::get_charges`] (wire method `getCharges`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetChargesResponseCharge {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub id: Option<u64>,
    #[serde(default, deserialize_with = "crate::responses::deserialize_opt_date")]
    pub date: Option<chrono::NaiveDate>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_decimal_from_string_or_number"
    )]
    pub amount: Option<rust_decimal::Decimal>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub description: Option<String>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetChargesResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub charges: Vec<GetChargesResponseCharge>,
}

/// Response body for [`Client::get_client_packages`] (wire method `getClientPackages`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetClientPackagesResponsePackage {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub value: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub description: Option<String>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetClientPackagesResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub packages: Vec<GetClientPackagesResponsePackage>,
}

/// Response body for [`Client::get_client_threshold`] (wire method `getClientThreshold`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetClientThresholdResponseThresholdInformation {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub threshold: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub email: Option<String>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetClientThresholdResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(default)]
    pub threshold_information: Option<GetClientThresholdResponseThresholdInformation>,
}

/// Response body for [`Client::get_clients`] (wire method `getClients`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetClientsResponseClient {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub client: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub email: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub password: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub company: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub firstname: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub lastname: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub address: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub city: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub state: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub country: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub zip: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub phone_number: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub balance_management: Option<u64>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetClientsResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub clients: Vec<GetClientsResponseClient>,
}

/// Response body for [`Client::get_conference`] (wire method `getConference`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetConferenceResponseConference {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub conference: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub name: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub description: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_max_members"
    )]
    pub max_members: Option<crate::MaxMembers>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub sound_join: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub sound_leave: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub sound_has_joined: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub sound_has_left: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub sound_kicked: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub sound_muted: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub sound_unmuted: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub sound_only_person: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub sound_only_one: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub sound_there_are: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub sound_other_in_party: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub sound_place_into_conference: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub sound_get_pin: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub sound_invalid_pin: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub sound_locked: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub sound_locked_now: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub sound_unlocked_now: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub sound_error_menu: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub sound_participants_muted: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub sound_participants_unmuted: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub language: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub members: Option<String>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetConferenceResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub conference: Vec<GetConferenceResponseConference>,
}

/// Response body for [`Client::get_conference_members`] (wire method `getConferenceMembers`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetConferenceMembersResponseMember {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub member: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub name: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub description: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub pin: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_bool_from_string_number_or_yn"
    )]
    pub announce_join_leave: Option<bool>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_bool_from_string_number_or_yn"
    )]
    pub admin: Option<bool>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_bool_from_string_number_or_yn"
    )]
    pub start_muted: Option<bool>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_bool_from_string_number_or_yn"
    )]
    pub announce_user_count: Option<bool>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_bool_from_string_number_or_yn"
    )]
    pub announce_only_user: Option<bool>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub moh_when_empty: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_bool_from_string_number_or_yn"
    )]
    pub quiet: Option<bool>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub announcement: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_bool_from_string_number_or_yn"
    )]
    pub drop_silence: Option<bool>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub talking_threshold: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub silence_threshold: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_bool_from_string_number_or_yn"
    )]
    pub talk_detection: Option<bool>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_bool_from_string_number_or_yn"
    )]
    pub jitter_buffer: Option<bool>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetConferenceMembersResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub members: Vec<GetConferenceMembersResponseMember>,
}

/// Response body for [`Client::get_conference_recording_file`] (wire method `getConferenceRecordingFile`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetConferenceRecordingFileResponseRecording {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub recording: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub data: Option<String>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetConferenceRecordingFileResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub recording: Vec<GetConferenceRecordingFileResponseRecording>,
}

/// Response body for [`Client::get_conference_recordings`] (wire method `getConferenceRecordings`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetConferenceRecordingsResponseRecording {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub did: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub recording: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub conference: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub duration: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_datetime"
    )]
    pub date: Option<chrono::NaiveDateTime>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetConferenceRecordingsResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub recordings: Vec<GetConferenceRecordingsResponseRecording>,
}

/// Response body for [`Client::get_countries`] (wire method `getCountries`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetCountriesResponseCountry {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub value: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub description: Option<String>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetCountriesResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub countries: Vec<GetCountriesResponseCountry>,
}

/// Response body for [`Client::get_did_countries`] (wire method `getDIDCountries`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetDIDCountriesResponseCountry {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub value: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub description: Option<String>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetDIDCountriesResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub countries: Vec<GetDIDCountriesResponseCountry>,
}

/// Response body for [`Client::get_dids_can`] (wire method `getDIDsCAN`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetDIDsCANResponseDID {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub did: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub ratecenter: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub province: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub province_description: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_decimal_from_string_or_number"
    )]
    pub perminute_monthly: Option<rust_decimal::Decimal>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_decimal_from_string_or_number"
    )]
    pub perminute_minute: Option<rust_decimal::Decimal>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_decimal_from_string_or_number"
    )]
    pub perminute_setup: Option<rust_decimal::Decimal>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_decimal_from_string_or_number"
    )]
    pub flat_monthly: Option<rust_decimal::Decimal>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_decimal_from_string_or_number"
    )]
    pub flat_minute: Option<rust_decimal::Decimal>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_decimal_from_string_or_number"
    )]
    pub flat_setup: Option<rust_decimal::Decimal>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub sms: Option<u64>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetDIDsCANResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub dids: Vec<GetDIDsCANResponseDID>,
}

/// Response body for [`Client::get_dids_info`] (wire method `getDIDsInfo`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetDIDsInfoResponseDID {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub did: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub description: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_routing"
    )]
    pub routing: Option<crate::Routing>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_routing"
    )]
    pub failover_busy: Option<crate::Routing>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_routing"
    )]
    pub failover_unreachable: Option<crate::Routing>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_routing"
    )]
    pub failover_noanswer: Option<crate::Routing>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub voicemail: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub pop: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub dialtime: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_bool_from_string_number_or_yn"
    )]
    pub cnam: Option<bool>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub e911: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub callerid_prefix: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub note: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub port_out_pin: Option<u64>,
    #[serde(default, deserialize_with = "deserialize_opt_did_billing_type")]
    pub billing_type: Option<DidBillingType>,
    #[serde(default, deserialize_with = "crate::responses::deserialize_opt_date")]
    pub next_billing: Option<chrono::NaiveDate>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_datetime"
    )]
    pub order_date: Option<chrono::NaiveDateTime>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub reseller_account: Option<String>,
    #[serde(default, deserialize_with = "crate::responses::deserialize_opt_date")]
    pub reseller_next_billing: Option<chrono::NaiveDate>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_decimal_from_string_or_number"
    )]
    pub reseller_monthly: Option<rust_decimal::Decimal>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_decimal_from_string_or_number"
    )]
    pub reseller_minute: Option<rust_decimal::Decimal>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_decimal_from_string_or_number"
    )]
    pub reseller_setup: Option<rust_decimal::Decimal>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_bool_from_string_number_or_yn"
    )]
    pub sms_available: Option<bool>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_bool_from_string_number_or_yn"
    )]
    pub sms_enabled: Option<bool>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub sms_email: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_bool_from_string_number_or_yn"
    )]
    pub sms_email_enabled: Option<bool>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_sentinel_none"
    )]
    pub sms_forward: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_bool_from_string_number_or_yn"
    )]
    pub sms_forward_enabled: Option<bool>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub sms_url_callback: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_bool_from_string_number_or_yn"
    )]
    pub sms_url_callback_enabled: Option<bool>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_bool_from_string_number_or_yn"
    )]
    pub sms_url_callback_retry: Option<bool>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_bool_from_string_number_or_yn"
    )]
    pub smpp_enabled: Option<bool>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub smpp_url: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub smpp_user: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub smpp_pass: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_bool_from_string_number_or_yn"
    )]
    pub transcribe: Option<bool>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub transcription_locale: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_bool_from_string_number_or_yn"
    )]
    pub transcription_redaction: Option<bool>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_bool_from_string_number_or_yn"
    )]
    pub transcription_summary: Option<bool>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_bool_from_string_number_or_yn"
    )]
    pub transcription_sentiment: Option<bool>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub transcription_email: Option<String>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetDIDsInfoResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub dids: Vec<GetDIDsInfoResponseDID>,
}

/// Response body for [`Client::get_dids_international_geographic`] (wire method `getDIDsInternationalGeographic`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetDIDsInternationalGeographicResponseLocation {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub location_id: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub location_name: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub country: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub area_code: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub stock: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_decimal_from_string_or_number"
    )]
    pub monthly: Option<rust_decimal::Decimal>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_decimal_from_string_or_number"
    )]
    pub setup: Option<rust_decimal::Decimal>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_decimal_from_string_or_number"
    )]
    pub minute: Option<rust_decimal::Decimal>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub monthly_per_minute: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub setup_per_minute: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub channels: Option<u64>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetDIDsInternationalGeographicResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub locations: Vec<GetDIDsInternationalGeographicResponseLocation>,
}

/// Response body for [`Client::get_dids_international_national`] (wire method `getDIDsInternationalNational`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetDIDsInternationalNationalResponseLocation {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub location_id: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub location_name: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub country: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub area_code: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub stock: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_decimal_from_string_or_number"
    )]
    pub monthly: Option<rust_decimal::Decimal>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub setup: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub minute: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub monthly_per_minute: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub setup_per_minute: Option<String>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetDIDsInternationalNationalResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub locations: Vec<GetDIDsInternationalNationalResponseLocation>,
}

/// Response body for [`Client::get_dids_international_toll_free`] (wire method `getDIDsInternationalTollFree`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetDIDsInternationalTollFreeResponseLocation {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub location_id: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub location_name: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub country: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub area_code: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub stock: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_decimal_from_string_or_number"
    )]
    pub monthly: Option<rust_decimal::Decimal>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_decimal_from_string_or_number"
    )]
    pub setup: Option<rust_decimal::Decimal>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_decimal_from_string_or_number"
    )]
    pub minute: Option<rust_decimal::Decimal>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetDIDsInternationalTollFreeResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub locations: Vec<GetDIDsInternationalTollFreeResponseLocation>,
}

/// Response body for [`Client::get_dids_usa`] (wire method `getDIDsUSA`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetDIDsUSAResponseDID {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub did: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub ratecenter: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub state: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub state_description: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_decimal_from_string_or_number"
    )]
    pub perminute_monthly: Option<rust_decimal::Decimal>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_decimal_from_string_or_number"
    )]
    pub perminute_minute: Option<rust_decimal::Decimal>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_decimal_from_string_or_number"
    )]
    pub perminute_setup: Option<rust_decimal::Decimal>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_decimal_from_string_or_number"
    )]
    pub flat_monthly: Option<rust_decimal::Decimal>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_decimal_from_string_or_number"
    )]
    pub flat_minute: Option<rust_decimal::Decimal>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_decimal_from_string_or_number"
    )]
    pub flat_setup: Option<rust_decimal::Decimal>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub has_port_out_pin: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub sms: Option<u64>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetDIDsUSAResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub dids: Vec<GetDIDsUSAResponseDID>,
}

/// Response body for [`Client::get_did_vpri`] (wire method `getDIDvPRI`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetDIDvPRIResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub dids: Vec<String>,
}

/// Response body for [`Client::get_disas`] (wire method `getDISAs`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetDISAsResponseDISA {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub disa: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub name: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub pin: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub digit_timeout: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_sentinel_none"
    )]
    pub callerid_override: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub language: Option<String>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetDISAsResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub disa: Vec<GetDISAsResponseDISA>,
}

/// Response body for [`Client::get_dtmf_modes`] (wire method `getDTMFModes`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetDTMFModesResponseDTMFMode {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub value: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub description: Option<String>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetDTMFModesResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub dtmf_modes: Vec<GetDTMFModesResponseDTMFMode>,
}

/// Response body for [`Client::get_deposits`] (wire method `getDeposits`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetDepositsResponseDeposit {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub id: Option<u64>,
    #[serde(default, deserialize_with = "crate::responses::deserialize_opt_date")]
    pub date: Option<chrono::NaiveDate>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_decimal_from_string_or_number"
    )]
    pub amount: Option<rust_decimal::Decimal>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub description: Option<String>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetDepositsResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub deposits: Vec<GetDepositsResponseDeposit>,
}

/// Response body for [`Client::get_device_types`] (wire method `getDeviceTypes`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetDeviceTypesResponseDeviceType {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub value: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub description: Option<String>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetDeviceTypesResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub device_types: Vec<GetDeviceTypesResponseDeviceType>,
}

/// Response body for [`Client::get_email_to_fax`] (wire method `getEmailToFax`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetEmailToFAXResponseEmailToFAX {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub id: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_bool_from_string_number_or_yn"
    )]
    pub enabled: Option<bool>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub email: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub security_code: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_bool_from_string_number_or_yn"
    )]
    pub security_code_enabled: Option<bool>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub from: Option<String>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetEmailToFAXResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq",
        rename = "emailToFax"
    )]
    pub email_to_fax: Vec<GetEmailToFAXResponseEmailToFAX>,
}

/// Response body for [`Client::get_fax_folders`] (wire method `getFaxFolders`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetFAXFoldersResponseFolder {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub id: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub name: Option<String>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetFAXFoldersResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub folders: Vec<GetFAXFoldersResponseFolder>,
}

/// Response body for [`Client::get_fax_message_pdf`] (wire method `getFaxMessagePDF`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetFAXMessagePDFResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub message_base64: Option<String>,
}

/// Response body for [`Client::get_fax_messages`] (wire method `getFaxMessages`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetFAXMessagesResponseFAX {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub id: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub folder: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_datetime"
    )]
    pub date: Option<chrono::NaiveDateTime>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub callerid: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub stationid: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub destination: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub description: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub pages: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub duration: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_decimal_from_string_or_number"
    )]
    pub rate: Option<rust_decimal::Decimal>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_decimal_from_string_or_number"
    )]
    pub total: Option<rust_decimal::Decimal>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub msg: Option<String>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetFAXMessagesResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub faxes: Vec<GetFAXMessagesResponseFAX>,
}

/// Response body for [`Client::get_fax_numbers_info`] (wire method `getFaxNumbersInfo`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetFAXNumbersInfoResponseNumber {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub id: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub did: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub description: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub state: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub city: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub country: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_bool_from_string_number_or_yn"
    )]
    pub email_enabled: Option<bool>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub email: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_bool_from_string_number_or_yn"
    )]
    pub url_enabled: Option<bool>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub url: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub retry: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub attach_file: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub note: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub reseller_account: Option<String>,
    #[serde(default, deserialize_with = "crate::responses::deserialize_opt_date")]
    pub reseller_next_billing: Option<chrono::NaiveDate>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_decimal_from_string_or_number"
    )]
    pub reseller_monthly: Option<rust_decimal::Decimal>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_decimal_from_string_or_number"
    )]
    pub reseller_minute: Option<rust_decimal::Decimal>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_decimal_from_string_or_number"
    )]
    pub reseller_setup: Option<rust_decimal::Decimal>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_bool_from_string_number_or_yn"
    )]
    pub fax_to_sip_enabled: Option<bool>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub fax_to_sip_enabled_account: Option<String>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetFAXNumbersInfoResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub numbers: Vec<GetFAXNumbersInfoResponseNumber>,
}

/// Response body for [`Client::get_fax_numbers_portability`] (wire method `getFaxNumbersPortability`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetFAXNumbersPortabilityResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_bool_from_string_number_or_yn",
        rename = "getFaxNumbersPortability"
    )]
    pub get_fax_numbers_portability: Option<bool>,
}

/// Response body for [`Client::get_fax_provinces`] (wire method `getFaxProvinces`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetFAXProvincesResponseProvince {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub province: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub province_id: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub province_name: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub country_code: Option<String>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetFAXProvincesResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub provinces: Vec<GetFAXProvincesResponseProvince>,
}

/// Response body for [`Client::get_fax_rate_centers_can`] (wire method `getFaxRateCentersCAN`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetFAXRateCentersCANResponseRatecenter {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub location: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub area_code: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub ratecenter: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_bool_from_string_number_or_yn"
    )]
    pub available: Option<bool>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetFAXRateCentersCANResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub ratecenters: Vec<GetFAXRateCentersCANResponseRatecenter>,
}

/// Response body for [`Client::get_fax_rate_centers_usa`] (wire method `getFaxRateCentersUSA`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetFAXRateCentersUSAResponseRatecenter {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub location: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub area_code: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub ratecenter: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_bool_from_string_number_or_yn"
    )]
    pub available: Option<bool>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetFAXRateCentersUSAResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub ratecenters: Vec<GetFAXRateCentersUSAResponseRatecenter>,
}

/// Response body for [`Client::get_fax_states`] (wire method `getFaxStates`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetFAXStatesResponseState {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub state: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub state_id: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub state_name: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub country_code: Option<String>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetFAXStatesResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub states: Vec<GetFAXStatesResponseState>,
}

/// Response body for [`Client::get_forwardings`] (wire method `getForwardings`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetForwardingsResponseForwarding {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub forwarding: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub phone_number: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_sentinel_none"
    )]
    pub callerid_override: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub description: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub dtmf_digits: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_decimal_from_string_or_number"
    )]
    pub pause: Option<rust_decimal::Decimal>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_bool_from_string_number_or_yn"
    )]
    pub diversion_header: Option<bool>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetForwardingsResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub forwardings: Vec<GetForwardingsResponseForwarding>,
}

/// Response body for [`Client::get_ip`] (wire method `getIP`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetIPResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub ip: Option<String>,
}

/// Response body for [`Client::get_ivrs`] (wire method `getIVRs`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetIVRsResponseIVR {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub ivr: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub name: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub recording: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub timeout: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub language: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub voicemailsetup: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub choices: Option<String>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetIVRsResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub ivrs: Vec<GetIVRsResponseIVR>,
}

/// Response body for [`Client::get_international_types`] (wire method `getInternationalTypes`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetInternationalTypesResponseType {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub value: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub description: Option<String>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetInternationalTypesResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub types: Vec<GetInternationalTypesResponseType>,
}

/// Response body for [`Client::get_join_when_empty_types`] (wire method `getJoinWhenEmptyTypes`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetJoinWhenEmptyTypesResponseType {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub value: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub description: Option<String>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetJoinWhenEmptyTypesResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub types: Vec<GetJoinWhenEmptyTypesResponseType>,
}

/// Response body for [`Client::get_lnp_attach`] (wire method `getLNPAttach`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetLNPAttachResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub r#type: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub size: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub base64: Option<String>,
}

/// Response body for [`Client::get_lnp_attach_list`] (wire method `getLNPAttachList`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetLNPAttachListResponseList {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub attachid: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub r#type: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub size: Option<String>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetLNPAttachListResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub list: Vec<GetLNPAttachListResponseList>,
}

/// Response body for [`Client::get_lnp_details`] (wire method `getLNPDetails`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetLNPDetailsResponseNumber {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub did: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool",
        rename = "rateCenter"
    )]
    pub rate_center: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub state: Option<String>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetLNPDetailsResponseNote {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub note: Option<String>,
    #[serde(default, deserialize_with = "crate::responses::deserialize_opt_date")]
    pub date: Option<chrono::NaiveDate>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub time: Option<String>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetLNPDetailsResponseAttachment {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub id: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub description: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub r#type: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub bytes: Option<u64>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetLNPDetailsResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub id: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub numbers: Vec<GetLNPDetailsResponseNumber>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_bool_from_string_number_or_yn",
        rename = "isPartial"
    )]
    pub is_partial: Option<bool>,
    #[serde(
        default,
        deserialize_with = "deserialize_opt_location_type",
        rename = "locationType"
    )]
    pub location_type: Option<LocationType>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_bool_from_string_number_or_yn",
        rename = "isMobile"
    )]
    pub is_mobile: Option<bool>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool",
        rename = "mobileInfo"
    )]
    pub mobile_info: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number",
        rename = "tfType"
    )]
    pub tf_type: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number",
        rename = "portType"
    )]
    pub port_type: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub btn: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub services: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool",
        rename = "statementName"
    )]
    pub statement_name: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool",
        rename = "firstName"
    )]
    pub first_name: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool",
        rename = "lastName"
    )]
    pub last_name: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub address1: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub address2: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub city: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub zip: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub state: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub country: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool",
        rename = "providerName"
    )]
    pub provider_name: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool",
        rename = "providerAccount"
    )]
    pub provider_account: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub customer_notes: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub notes: Vec<GetLNPDetailsResponseNote>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub post_status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub post_status_description: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_datetime"
    )]
    pub date: Option<chrono::NaiveDateTime>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool",
        rename = "focDate"
    )]
    pub foc_date: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub attachments: Vec<GetLNPDetailsResponseAttachment>,
}

/// Response body for [`Client::get_lnp_list`] (wire method `getLNPList`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetLNPListResponseList {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub portid: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub numbers: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub foc_date: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetLNPListResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub list: Vec<GetLNPListResponseList>,
}

/// Response body for [`Client::get_lnp_list_status`] (wire method `getLNPListStatus`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetLNPListStatusResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_map_from_object"
    )]
    pub list_status: std::collections::HashMap<String, String>,
}

/// Response body for [`Client::get_lnp_notes`] (wire method `getLNPNotes`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetLNPNotesResponseList {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub note: Option<String>,
    #[serde(default, deserialize_with = "crate::responses::deserialize_opt_date")]
    pub date: Option<chrono::NaiveDate>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub time: Option<String>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetLNPNotesResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub list: Vec<GetLNPNotesResponseList>,
}

/// Response body for [`Client::get_lnp_status`] (wire method `getLNPStatus`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetLNPStatusResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub post_status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub post_status_description: Option<String>,
}

/// Response body for [`Client::get_languages`] (wire method `getLanguages`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetLanguagesResponseLanguage {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub value: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub description: Option<String>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetLanguagesResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub languages: Vec<GetLanguagesResponseLanguage>,
}

/// Response body for [`Client::get_locales`] (wire method `getLocales`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetLocalesResponseLocale {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub value: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub description: Option<String>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetLocalesResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub locales: Vec<GetLocalesResponseLocale>,
}

/// Response body for [`Client::get_locations`] (wire method `getLocations`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetLocationsResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub locations: Vec<String>,
}

/// Response body for [`Client::get_lock_international`] (wire method `getLockInternational`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetLockInternationalResponseLockInternational {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub value: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub description: Option<String>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetLockInternationalResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub lock_international: Vec<GetLockInternationalResponseLockInternational>,
}

/// Response body for [`Client::get_mms`] (wire method `getMMS`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetMMSResponseSMS {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub id: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_datetime"
    )]
    pub date: Option<chrono::NaiveDateTime>,
    #[serde(default, deserialize_with = "deserialize_opt_message_type")]
    pub r#type: Option<MessageType>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub did: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub contact: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub message: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub carrier_status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub col_media1: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub col_media2: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub col_media3: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub media: Vec<String>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetMMSResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub sms: Vec<GetMMSResponseSMS>,
}

/// Response body for [`Client::get_media_mms`] (wire method `getMediaMMS`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetMediaMMSResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub id: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_datetime"
    )]
    pub date: Option<chrono::NaiveDateTime>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_map_from_object"
    )]
    pub media: std::collections::HashMap<String, String>,
}

/// Response body for [`Client::get_music_on_hold`] (wire method `getMusicOnHold`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetMusicOnHoldResponseMusicOnHold {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub value: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub description: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub recordings: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub total: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub volume: Option<String>,
    #[serde(default, deserialize_with = "deserialize_opt_recording_sort")]
    pub sort: Option<RecordingSort>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub custom: Option<u64>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetMusicOnHoldResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub music_on_hold: Vec<GetMusicOnHoldResponseMusicOnHold>,
}

/// Response body for [`Client::get_nat`] (wire method `getNAT`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetNATResponseNAT {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub value: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub description: Option<String>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetNATResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub nat: Vec<GetNATResponseNAT>,
}

/// Response body for [`Client::get_packages`] (wire method `getPackages`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetPackagesResponsePackage {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub package: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub name: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_decimal_from_string_or_number"
    )]
    pub markup_fixed: Option<rust_decimal::Decimal>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub markup_percentage: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub pulse: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub international_route: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub canada_route: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_decimal_from_string_or_number"
    )]
    pub monthly_fee: Option<rust_decimal::Decimal>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_decimal_from_string_or_number"
    )]
    pub setup_fee: Option<rust_decimal::Decimal>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub free_minutes: Option<u64>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetPackagesResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub packages: Vec<GetPackagesResponsePackage>,
}

/// Response body for [`Client::get_phonebook`] (wire method `getPhonebook`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetPhonebookResponsePhonebook {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub phonebook: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub speed_dial: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub name: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub number: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub callerid: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub note: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub group: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub group_name: Option<String>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetPhonebookResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub phonebooks: Vec<GetPhonebookResponsePhonebook>,
}

/// Response body for [`Client::get_phonebook_groups`] (wire method `getPhonebookGroups`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetPhonebookGroupsResponsePhonebook {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub phonebook_group: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub name: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub members: Option<String>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetPhonebookGroupsResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub phonebooks: Vec<GetPhonebookGroupsResponsePhonebook>,
}

/// Response body for [`Client::get_play_instructions`] (wire method `getPlayInstructions`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetPlayInstructionsResponsePlayInstruction {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub value: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub description: Option<String>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetPlayInstructionsResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub play_instructions: Vec<GetPlayInstructionsResponsePlayInstruction>,
}

/// Response body for [`Client::get_portability`] (wire method `getPortability`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetPortabilityResponsePlan {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub title: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_decimal_from_string_or_number",
        rename = "pricePerMonth"
    )]
    pub price_per_month: Option<rust_decimal::Decimal>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_decimal_from_string_or_number",
        rename = "pricePerMin"
    )]
    pub price_per_min: Option<rust_decimal::Decimal>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetPortabilityResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_bool_from_string_number_or_yn"
    )]
    pub portable: Option<bool>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_bool_from_string_number_or_yn"
    )]
    pub sms: Option<bool>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub plans: Vec<GetPortabilityResponsePlan>,
}

/// Response body for [`Client::get_protocols`] (wire method `getProtocols`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetProtocolsResponseProtocol {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub value: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub description: Option<String>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetProtocolsResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub protocols: Vec<GetProtocolsResponseProtocol>,
}

/// Response body for [`Client::get_provinces`] (wire method `getProvinces`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetProvincesResponseProvince {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub province: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub description: Option<String>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetProvincesResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub provinces: Vec<GetProvincesResponseProvince>,
}

/// Response body for [`Client::get_queues`] (wire method `getQueues`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetQueuesResponseQueue {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub queue: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub queue_name: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub queue_number: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub queue_language: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub queue_password: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub callerid_prefix: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub join_announcement: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub priority_weight: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub agent_announcement: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_bool_from_string_number_or_yn"
    )]
    pub report_hold_time_agent: Option<bool>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_seconds"
    )]
    pub member_delay: Option<crate::Seconds>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub music_on_hold: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_wait_time"
    )]
    pub maximum_wait_time: Option<crate::WaitTime>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub maximum_callers: Option<u64>,
    #[serde(default, deserialize_with = "deserialize_opt_queue_empty_behavior")]
    pub join_when_empty: Option<QueueEmptyBehavior>,
    #[serde(default, deserialize_with = "deserialize_opt_queue_empty_behavior")]
    pub leave_when_empty: Option<QueueEmptyBehavior>,
    #[serde(default, deserialize_with = "deserialize_opt_ring_strategy")]
    pub ring_strategy: Option<RingStrategy>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_bool_from_string_number_or_yn"
    )]
    pub ring_inuse: Option<bool>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub agent_ring_timeout: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_seconds"
    )]
    pub retry_timer: Option<crate::Seconds>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_seconds"
    )]
    pub wrapup_time: Option<crate::Seconds>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub voice_announcement: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_seconds"
    )]
    pub frequency_announcement: Option<crate::Seconds>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_seconds"
    )]
    pub announce_position_frecuency: Option<crate::Seconds>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_seconds"
    )]
    pub announce_round_seconds: Option<crate::Seconds>,
    #[serde(
        default,
        deserialize_with = "deserialize_opt_estimated_hold_time_announce"
    )]
    pub if_announce_position_enabled_report_estimated_hold_time: Option<EstimatedHoldTimeAnnounce>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_bool_from_string_number_or_yn"
    )]
    pub thankyou_for_your_patience: Option<bool>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_routing"
    )]
    pub fail_over_routing_timeout: Option<crate::Routing>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_routing"
    )]
    pub fail_over_routing_full: Option<crate::Routing>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_routing"
    )]
    pub fail_over_routing_join_empty: Option<crate::Routing>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_routing"
    )]
    pub fail_over_routing_leave_empty: Option<crate::Routing>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_routing"
    )]
    pub fail_over_routing_join_unavail: Option<crate::Routing>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_routing"
    )]
    pub fail_over_routing_leave_unavail: Option<crate::Routing>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetQueuesResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub queues: Vec<GetQueuesResponseQueue>,
}

/// Response body for [`Client::get_rate_centers_can`] (wire method `getRateCentersCAN`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetRateCentersCANResponseRatecenter {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub ratecenter: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_bool_from_string_number_or_yn"
    )]
    pub available: Option<bool>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetRateCentersCANResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub ratecenters: Vec<GetRateCentersCANResponseRatecenter>,
}

/// Response body for [`Client::get_rate_centers_usa`] (wire method `getRateCentersUSA`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetRateCentersUSAResponseRatecenter {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub ratecenter: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_bool_from_string_number_or_yn"
    )]
    pub available: Option<bool>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetRateCentersUSAResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub ratecenters: Vec<GetRateCentersUSAResponseRatecenter>,
}

/// Response body for [`Client::get_rates`] (wire method `getRates`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetRatesResponseRate {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub destination: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub prefix: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub client_increment: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_decimal_from_string_or_number"
    )]
    pub client_rate: Option<rust_decimal::Decimal>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub real_increment: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_decimal_from_string_or_number"
    )]
    pub real_rate: Option<rust_decimal::Decimal>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetRatesResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub rates: Vec<GetRatesResponseRate>,
}

/// Response body for [`Client::get_recording_file`] (wire method `getRecordingFile`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetRecordingFileResponseRecording {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub value: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub data: Option<String>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetRecordingFileResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub recordings: Vec<GetRecordingFileResponseRecording>,
}

/// Response body for [`Client::get_recordings`] (wire method `getRecordings`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetRecordingsResponseRecording {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub value: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub description: Option<String>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetRecordingsResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub recordings: Vec<GetRecordingsResponseRecording>,
}

/// Response body for [`Client::get_registration_status`] (wire method `getRegistrationStatus`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetRegistrationStatusResponseRegistration {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub server_name: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub server_shortname: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub server_hostname: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub server_ip: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub server_country: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub server_pop: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub register_ip: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub register_port: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_datetime"
    )]
    pub register_next: Option<chrono::NaiveDateTime>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub register_protocol: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub register_transport: Option<String>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetRegistrationStatusResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_bool_from_string_number_or_yn"
    )]
    pub registered: Option<bool>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub rerouted: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub from_server_pop: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub registrations: Vec<GetRegistrationStatusResponseRegistration>,
}

/// Response body for [`Client::get_report_estimated_hold_time`] (wire method `getReportEstimatedHoldTime`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetReportEstimatedHoldTimeResponseType {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub value: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub description: Option<String>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetReportEstimatedHoldTimeResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub types: Vec<GetReportEstimatedHoldTimeResponseType>,
}

/// Response body for [`Client::get_reseller_balance`] (wire method `getResellerBalance`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetResellerBalanceResponseBalance {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_decimal_from_string_or_number"
    )]
    pub current_balance: Option<rust_decimal::Decimal>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_decimal_from_string_or_number"
    )]
    pub spent_total: Option<rust_decimal::Decimal>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub calls_total: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub time_total: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_decimal_from_string_or_number"
    )]
    pub spent_today: Option<rust_decimal::Decimal>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub calls_today: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub time_today: Option<String>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetResellerBalanceResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(default)]
    pub balance: Option<GetResellerBalanceResponseBalance>,
}

/// Response body for [`Client::get_reseller_cdr`] (wire method `getResellerCDR`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetResellerCDRResponseCDR {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_datetime"
    )]
    pub date: Option<chrono::NaiveDateTime>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub callerid: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub destination: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub description: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub account: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub disposition: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub duration: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub seconds: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_decimal_from_string_or_number"
    )]
    pub total: Option<rust_decimal::Decimal>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub uniqueid: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub destination_type: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub call_logs: Option<String>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetResellerCDRResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub cdr: Vec<GetResellerCDRResponseCDR>,
}

/// Response body for [`Client::get_reseller_mms`] (wire method `getResellerMMS`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetResellerMMSResponseSMS {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub id: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_datetime"
    )]
    pub date: Option<chrono::NaiveDateTime>,
    #[serde(default, deserialize_with = "deserialize_opt_message_type")]
    pub r#type: Option<MessageType>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub did: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub contact: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub message: Option<String>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetResellerMMSResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub sms: Vec<GetResellerMMSResponseSMS>,
}

/// Response body for [`Client::get_reseller_sms`] (wire method `getResellerSMS`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetResellerSMSResponseSMS {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub id: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_datetime"
    )]
    pub date: Option<chrono::NaiveDateTime>,
    #[serde(default, deserialize_with = "deserialize_opt_message_type")]
    pub r#type: Option<MessageType>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub did: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub contact: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub message: Option<String>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetResellerSMSResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub sms: Vec<GetResellerSMSResponseSMS>,
}

/// Response body for [`Client::get_ring_groups`] (wire method `getRingGroups`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetRingGroupsResponseRingGroup {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub ring_group: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub name: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub caller_announcement: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub music_on_hold: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub language: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub members: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub voicemail: Option<u64>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetRingGroupsResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub ring_groups: Vec<GetRingGroupsResponseRingGroup>,
}

/// Response body for [`Client::get_ring_strategies`] (wire method `getRingStrategies`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetRingStrategiesResponseStrategy {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub value: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub description: Option<String>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetRingStrategiesResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub strategies: Vec<GetRingStrategiesResponseStrategy>,
}

/// Response body for [`Client::get_routes`] (wire method `getRoutes`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetRoutesResponseRoute {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub value: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub description: Option<String>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetRoutesResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub routes: Vec<GetRoutesResponseRoute>,
}

/// Response body for [`Client::get_sip_uris`] (wire method `getSIPURIs`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetSIPURIsResponseSIPURI {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number",
        rename = "sipuri"
    )]
    pub sip_uri: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub uri: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub description: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_sentinel_none"
    )]
    pub callerid_override: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub callerid_e164: Option<u64>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetSIPURIsResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq",
        rename = "sipuris"
    )]
    pub sip_uris: Vec<GetSIPURIsResponseSIPURI>,
}

/// Response body for [`Client::get_sms`] (wire method `getSMS`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetSMSResponseSMS {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub id: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_datetime"
    )]
    pub date: Option<chrono::NaiveDateTime>,
    #[serde(default, deserialize_with = "deserialize_opt_message_type")]
    pub r#type: Option<MessageType>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub did: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub contact: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub message: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub carrier_status: Option<String>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetSMSResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub sms: Vec<GetSMSResponseSMS>,
}

/// Response body for [`Client::get_servers_info`] (wire method `getServersInfo`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetServersInfoResponseServer {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub server_name: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub server_shortname: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub server_hostname: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub server_ip: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub server_country: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub server_pop: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_bool_from_string_number_or_yn"
    )]
    pub server_recommended: Option<bool>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetServersInfoResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub servers: Vec<GetServersInfoResponseServer>,
}

/// Response body for [`Client::get_states`] (wire method `getStates`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetStatesResponseState {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub state: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub description: Option<String>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetStatesResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub states: Vec<GetStatesResponseState>,
}

/// Response body for [`Client::get_static_members`] (wire method `getStaticMembers`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetStaticMembersResponseMember {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub member: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub queue_number: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub name: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub account: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub priority: Option<u64>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetStaticMembersResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub members: Vec<GetStaticMembersResponseMember>,
}

/// Response body for [`Client::get_sub_accounts`] (wire method `getSubAccounts`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetSubAccountsResponseAccount {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub id: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub account: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub username: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub description: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub protocol: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub auth_type: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub password: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub ip: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub device_type: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_sentinel_none"
    )]
    pub callerid_number: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub canada_routing: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub lock_international: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub international_route: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub music_on_hold: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub language: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub allowed_codecs: Option<String>,
    #[serde(default, deserialize_with = "deserialize_opt_dtmf_mode")]
    pub dtmf_mode: Option<DtmfMode>,
    #[serde(default, deserialize_with = "deserialize_opt_nat")]
    pub nat: Option<Nat>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub sip_traffic: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub max_expiry: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub rtp_timeout: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub rtp_hold_timeout: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub ip_restriction: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_bool_from_string_number_or_yn"
    )]
    pub enable_ip_restriction: Option<bool>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub pop_restriction: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_bool_from_string_number_or_yn"
    )]
    pub enable_pop_restriction: Option<bool>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_bool_from_string_number_or_yn"
    )]
    pub send_bye: Option<bool>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_bool_from_string_number_or_yn"
    )]
    pub record_calls: Option<bool>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub internal_extension: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub internal_voicemail: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub internal_dialtime: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub reseller_client: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub reseller_package: Option<u64>,
    #[serde(default, deserialize_with = "crate::responses::deserialize_opt_date")]
    pub reseller_nextbilling: Option<chrono::NaiveDate>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_bool_from_string_number_or_yn"
    )]
    pub transcribe: Option<bool>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub transcription_locale: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_bool_from_string_number_or_yn"
    )]
    pub transcription_redaction: Option<bool>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_bool_from_string_number_or_yn"
    )]
    pub transcription_summary: Option<bool>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_bool_from_string_number_or_yn"
    )]
    pub transcription_sentiment: Option<bool>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub transcription_email: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub parking_lot: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_bool_from_string_number_or_yn"
    )]
    pub enable_internal_cnam: Option<bool>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub internal_cnam: Option<String>,
    #[serde(default, deserialize_with = "deserialize_opt_toll_free_carrier")]
    pub tfcarrier: Option<TollFreeCarrier>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_sentinel_none"
    )]
    pub default_e911: Option<String>,
    #[serde(default, deserialize_with = "deserialize_opt_call_pickup_behavior")]
    pub call_pickup_behavior: Option<CallPickupBehavior>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetSubAccountsResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub accounts: Vec<GetSubAccountsResponseAccount>,
}

/// Response body for [`Client::get_termination_rates`] (wire method `getTerminationRates`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetTerminationRatesResponseRoute {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub value: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub description: Option<String>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetTerminationRatesResponseRate {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub destination: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub prefix: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub increment: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_decimal_from_string_or_number"
    )]
    pub rate: Option<rust_decimal::Decimal>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetTerminationRatesResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub route: Vec<GetTerminationRatesResponseRoute>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub rates: Vec<GetTerminationRatesResponseRate>,
}

/// Response body for [`Client::get_time_conditions`] (wire method `getTimeConditions`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetTimeConditionsResponseTimecondition {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub timecondition: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub name: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_routing"
    )]
    pub routing_match: Option<crate::Routing>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_routing"
    )]
    pub routing_nomatch: Option<crate::Routing>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub starthour: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub startminute: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub endhour: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub endminute: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub weekdaystart: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub weekdayend: Option<String>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetTimeConditionsResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub timecondition: Vec<GetTimeConditionsResponseTimecondition>,
}

/// Response body for [`Client::get_timezones`] (wire method `getTimezones`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetTimezonesResponseTimezone {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_timezone_name"
    )]
    pub value: Option<crate::TimezoneName>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub description: Option<String>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetTimezonesResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub timezones: Vec<GetTimezonesResponseTimezone>,
}

/// Response body for [`Client::get_transaction_history`] (wire method `getTransactionHistory`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetTransactionHistoryResponseTransaction {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_datetime"
    )]
    pub date: Option<chrono::NaiveDateTime>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub uniqueid: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub r#type: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub description: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_decimal_from_string_or_number"
    )]
    pub ammount: Option<rust_decimal::Decimal>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetTransactionHistoryResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub transactions: Vec<GetTransactionHistoryResponseTransaction>,
}

/// Response body for [`Client::get_vpris`] (wire method `getVPRIs`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetVPRIsResponseVPRI {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub vpri: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub name: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub note: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub channels: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_decimal_from_string_or_number"
    )]
    pub monthly_fee: Option<rust_decimal::Decimal>,
    #[serde(default, deserialize_with = "crate::responses::deserialize_opt_date")]
    pub next_billing: Option<chrono::NaiveDate>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_bool_from_string_number_or_yn"
    )]
    pub burst_enabled: Option<bool>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub burst_max_channels: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub burst_percentage_charge: Option<u64>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetVPRIsResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub vpri: Vec<GetVPRIsResponseVPRI>,
}

/// Response body for [`Client::get_voicemail_attachment_formats`] (wire method `getVoicemailAttachmentFormats`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetVoicemailAttachmentFormatsResponseEmailAttachmentFormat {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub value: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub description: Option<String>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetVoicemailAttachmentFormatsResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub email_attachment_formats: Vec<GetVoicemailAttachmentFormatsResponseEmailAttachmentFormat>,
}

/// Response body for [`Client::get_voicemail_folders`] (wire method `getVoicemailFolders`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetVoicemailFoldersResponseFolder {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub value: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub description: Option<String>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetVoicemailFoldersResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub folders: Vec<GetVoicemailFoldersResponseFolder>,
}

/// Response body for [`Client::get_voicemail_message_file`] (wire method `getVoicemailMessageFile`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetVoicemailMessageFileResponseMessage {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub mailbox: Option<u64>,
    #[serde(default, deserialize_with = "deserialize_opt_voicemail_folder")]
    pub folder: Option<VoicemailFolder>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub message_num: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub data: Option<String>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetVoicemailMessageFileResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub message: Vec<GetVoicemailMessageFileResponseMessage>,
}

/// Response body for [`Client::get_voicemail_messages`] (wire method `getVoicemailMessages`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetVoicemailMessagesResponseMessage {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub mailbox: Option<u64>,
    #[serde(default, deserialize_with = "deserialize_opt_voicemail_folder")]
    pub folder: Option<VoicemailFolder>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub message_num: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_datetime"
    )]
    pub date: Option<chrono::NaiveDateTime>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub callerid: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub duration: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_bool_from_string_number_or_yn"
    )]
    pub urgent: Option<bool>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_bool_from_string_number_or_yn"
    )]
    pub listened: Option<bool>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetVoicemailMessagesResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub messages: Vec<GetVoicemailMessagesResponseMessage>,
}

/// Response body for [`Client::get_voicemail_setups`] (wire method `getVoicemailSetups`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetVoicemailSetupsResponseVoicemailsetup {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub value: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub description: Option<String>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetVoicemailSetupsResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub voicemailsetups: Vec<GetVoicemailSetupsResponseVoicemailsetup>,
}

/// Response body for [`Client::get_voicemail_transcriptions`] (wire method `getVoicemailTranscriptions`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetVoicemailTranscriptionsResponseMessage {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub date: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub callerid: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub duration: Option<String>,
    #[serde(default, deserialize_with = "deserialize_opt_voicemail_folder")]
    pub folder: Option<VoicemailFolder>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub result: Option<String>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetVoicemailTranscriptionsResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub messages: Vec<GetVoicemailTranscriptionsResponseMessage>,
}

/// Response body for [`Client::get_voicemails`] (wire method `getVoicemails`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetVoicemailsResponseVoicemail {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub mailbox: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub name: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub password: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_bool_from_string_number_or_yn"
    )]
    pub skip_password: Option<bool>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub email: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_bool_from_string_number_or_yn"
    )]
    pub attach_message: Option<bool>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_bool_from_string_number_or_yn"
    )]
    pub delete_message: Option<bool>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_bool_from_string_number_or_yn"
    )]
    pub say_time: Option<bool>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_timezone_name"
    )]
    pub timezone: Option<crate::TimezoneName>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_bool_from_string_number_or_yn"
    )]
    pub say_callerid: Option<bool>,
    #[serde(default, deserialize_with = "deserialize_opt_play_instructions")]
    pub play_instructions: Option<PlayInstructions>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub language: Option<String>,
    #[serde(default, deserialize_with = "deserialize_opt_email_attachment_format")]
    pub email_attachment_format: Option<EmailAttachmentFormat>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub unavailable_message_recording: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub new: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub urgent: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_bool_from_string_number_or_yn"
    )]
    pub transcription: Option<bool>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub transcription_locale: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_bool_from_string_number_or_yn"
    )]
    pub transcription_redaction: Option<bool>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_bool_from_string_number_or_yn"
    )]
    pub transcription_sentiment: Option<bool>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_bool_from_string_number_or_yn"
    )]
    pub transcription_summary: Option<bool>,
    #[serde(default, deserialize_with = "deserialize_opt_transcription_format")]
    pub transcription_format: Option<TranscriptionFormat>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub transcription_delay: Option<u64>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct GetVoicemailsResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub voicemails: Vec<GetVoicemailsResponseVoicemail>,
}

/// Response body for [`Client::mail_fax_message_pdf`] (wire method `mailFaxMessagePDF`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct MailFAXMessagePDFResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub message_status: Option<String>,
}

/// Response body for [`Client::mark_listened_voicemail_message`] (wire method `markListenedVoicemailMessage`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct MarkListenedVoicemailMessageResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
}

/// Response body for [`Client::mark_urgent_voicemail_message`] (wire method `markUrgentVoicemailMessage`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct MarkUrgentVoicemailMessageResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
}

/// Response body for [`Client::move_fax_message`] (wire method `moveFaxMessage`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct MoveFAXMessageResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
}

/// Response body for [`Client::move_folder_voicemail_message`] (wire method `moveFolderVoicemailMessage`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct MoveFolderVoicemailMessageResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
}

/// Response body for [`Client::order_did`] (wire method `orderDID`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct OrderDIDResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
}

/// Response body for [`Client::order_did_international_geographic`] (wire method `orderDIDInternationalGeographic`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct OrderDIDInternationalGeographicResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
}

/// Response body for [`Client::order_did_international_national`] (wire method `orderDIDInternationalNational`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct OrderDIDInternationalNationalResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
}

/// Response body for [`Client::order_did_international_toll_free`] (wire method `orderDIDInternationalTollFree`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct OrderDIDInternationalTollFreeResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
}

/// Response body for [`Client::order_did_virtual`] (wire method `orderDIDVirtual`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct OrderDIDVirtualResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
}

/// Response body for [`Client::order_fax_number`] (wire method `orderFaxNumber`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct OrderFAXNumberResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub dids: Vec<String>,
}

/// Response body for [`Client::order_toll_free`] (wire method `orderTollFree`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct OrderTollFreeResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
}

/// Response body for [`Client::order_vanity`] (wire method `orderVanity`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct OrderVanityResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
}

/// Response body for [`Client::remove_did_vpri`] (wire method `removeDIDvPRI`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct RemoveDIDvPRIResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub vpri: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool",
        rename = "DIDRemoved"
    )]
    pub did_removed: Option<String>,
}

/// Response body for [`Client::search_dids_can`] (wire method `searchDIDsCAN`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct SearchDIDsCANResponseDID {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub did: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub ratecenter: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub province: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub province_description: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_decimal_from_string_or_number"
    )]
    pub perminute_monthly: Option<rust_decimal::Decimal>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_decimal_from_string_or_number"
    )]
    pub perminute_minute: Option<rust_decimal::Decimal>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_decimal_from_string_or_number"
    )]
    pub perminute_setup: Option<rust_decimal::Decimal>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_decimal_from_string_or_number"
    )]
    pub flat_monthly: Option<rust_decimal::Decimal>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_decimal_from_string_or_number"
    )]
    pub flat_minute: Option<rust_decimal::Decimal>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_decimal_from_string_or_number"
    )]
    pub flat_setup: Option<rust_decimal::Decimal>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct SearchDIDsCANResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub dids: Vec<SearchDIDsCANResponseDID>,
}

/// Response body for [`Client::search_dids_usa`] (wire method `searchDIDsUSA`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct SearchDIDsUSAResponseDID {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub did: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub ratecenter: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub state: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub state_description: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_decimal_from_string_or_number"
    )]
    pub perminute_monthly: Option<rust_decimal::Decimal>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_decimal_from_string_or_number"
    )]
    pub perminute_minute: Option<rust_decimal::Decimal>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_decimal_from_string_or_number"
    )]
    pub perminute_setup: Option<rust_decimal::Decimal>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_decimal_from_string_or_number"
    )]
    pub flat_monthly: Option<rust_decimal::Decimal>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_decimal_from_string_or_number"
    )]
    pub flat_minute: Option<rust_decimal::Decimal>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_decimal_from_string_or_number"
    )]
    pub flat_setup: Option<rust_decimal::Decimal>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct SearchDIDsUSAResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub dids: Vec<SearchDIDsUSAResponseDID>,
}

/// Response body for [`Client::search_fax_area_code_can`] (wire method `searchFaxAreaCodeCAN`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct SearchFAXAreaCodeCANResponseRatecenter {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub area_code: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_bool_from_string_number_or_yn"
    )]
    pub available: Option<bool>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub ratecenter: Option<String>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct SearchFAXAreaCodeCANResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub ratecenters: Vec<SearchFAXAreaCodeCANResponseRatecenter>,
}

/// Response body for [`Client::search_fax_area_code_usa`] (wire method `searchFaxAreaCodeUSA`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct SearchFAXAreaCodeUSAResponseRatecenter {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub area_code: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_bool_from_string_number_or_yn"
    )]
    pub available: Option<bool>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub ratecenter: Option<String>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct SearchFAXAreaCodeUSAResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub ratecenters: Vec<SearchFAXAreaCodeUSAResponseRatecenter>,
}

/// Response body for [`Client::search_toll_free_can_us`] (wire method `searchTollFreeCanUS`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct SearchTollFreeCANUSResponseDID {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub did: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_decimal_from_string_or_number"
    )]
    pub monthly: Option<rust_decimal::Decimal>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_decimal_from_string_or_number"
    )]
    pub minute: Option<rust_decimal::Decimal>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_decimal_from_string_or_number"
    )]
    pub setup: Option<rust_decimal::Decimal>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct SearchTollFreeCANUSResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub dids: Vec<SearchTollFreeCANUSResponseDID>,
}

/// Response body for [`Client::search_toll_free_usa`] (wire method `searchTollFreeUSA`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct SearchTollFreeUSAResponseDID {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub did: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_decimal_from_string_or_number"
    )]
    pub monthly: Option<rust_decimal::Decimal>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_decimal_from_string_or_number"
    )]
    pub minute_usa: Option<rust_decimal::Decimal>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_decimal_from_string_or_number"
    )]
    pub minute_canada: Option<rust_decimal::Decimal>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_decimal_from_string_or_number"
    )]
    pub minute_puertorico: Option<rust_decimal::Decimal>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_decimal_from_string_or_number"
    )]
    pub minute_alaska: Option<rust_decimal::Decimal>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub setup: Option<u64>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct SearchTollFreeUSAResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub dids: Vec<SearchTollFreeUSAResponseDID>,
}

/// Response body for [`Client::search_vanity`] (wire method `searchVanity`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct SearchVanityResponseDID {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub did: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_decimal_from_string_or_number"
    )]
    pub monthly_american: Option<rust_decimal::Decimal>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_decimal_from_string_or_number"
    )]
    pub monthly_canadian: Option<rust_decimal::Decimal>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_decimal_from_string_or_number"
    )]
    pub minute_american_usa: Option<rust_decimal::Decimal>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_decimal_from_string_or_number"
    )]
    pub minute_american_canada: Option<rust_decimal::Decimal>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_decimal_from_string_or_number"
    )]
    pub minute_canadian: Option<rust_decimal::Decimal>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub setup_american: Option<u64>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub setup_canadian: Option<u64>,
}

#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct SearchVanityResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_vec_from_single_or_seq"
    )]
    pub dids: Vec<SearchVanityResponseDID>,
}

/// Response body for [`Client::send_call_recording_email`] (wire method `sendCallRecordingEmail`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct SendCallRecordingEmailResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub msg: Option<String>,
}

/// Response body for [`Client::send_fax_message`] (wire method `sendFaxMessage`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct SendFAXMessageResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
}

/// Response body for [`Client::send_mms`] (wire method `sendMMS`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct SendMMSResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub mms: Option<u64>,
}

/// Response body for [`Client::send_sms`] (wire method `sendSMS`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct SendSMSResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub sms: Option<u64>,
}

/// Response body for [`Client::send_voicemail_email`] (wire method `sendVoicemailEmail`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct SendVoicemailEmailResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
}

/// Response body for [`Client::set_call_hunting`] (wire method `setCallHunting`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct SetCallHuntingResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub call_hunting: Option<u64>,
}

/// Response body for [`Client::set_call_parking`] (wire method `setCallParking`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct SetCallParkingResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub callparking: Option<u64>,
}

/// Response body for [`Client::set_callback`] (wire method `setCallback`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct SetCallbackResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub callback: Option<u64>,
}

/// Response body for [`Client::set_caller_id_filtering`] (wire method `setCallerIDFiltering`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct SetCallerIDFilteringResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub filtering: Option<u64>,
}

/// Response body for [`Client::set_client`] (wire method `setClient`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct SetClientResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
}

/// Response body for [`Client::set_client_threshold`] (wire method `setClientThreshold`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct SetClientThresholdResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
}

/// Response body for [`Client::set_conference`] (wire method `setConference`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct SetConferenceResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub conference: Option<u64>,
}

/// Response body for [`Client::set_conference_member`] (wire method `setConferenceMember`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct SetConferenceMemberResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub member: Option<u64>,
}

/// Response body for [`Client::set_did_billing_type`] (wire method `setDIDBillingType`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct SetDIDBillingTypeResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
}

/// Response body for [`Client::set_did_info`] (wire method `setDIDInfo`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct SetDIDInfoResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
}

/// Response body for [`Client::set_did_pop`] (wire method `setDIDPOP`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct SetDIDPOPResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
}

/// Response body for [`Client::set_did_routing`] (wire method `setDIDRouting`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct SetDIDRoutingResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
}

/// Response body for [`Client::set_did_voicemail`] (wire method `setDIDVoicemail`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct SetDIDVoicemailResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
}

/// Response body for [`Client::set_disa`] (wire method `setDISA`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct SetDISAResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub disa: Option<u64>,
}

/// Response body for [`Client::set_email_to_fax`] (wire method `setEmailToFax`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct SetEmailToFAXResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
}

/// Response body for [`Client::set_fax_folder`] (wire method `setFaxFolder`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct SetFAXFolderResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
}

/// Response body for [`Client::set_fax_number_email`] (wire method `setFaxNumberEmail`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct SetFAXNumberEmailResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
}

/// Response body for [`Client::set_fax_number_info`] (wire method `setFaxNumberInfo`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct SetFAXNumberInfoResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
}

/// Response body for [`Client::set_fax_number_url_callback`] (wire method `setFaxNumberURLCallback`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct SetFAXNumberURLCallbackResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
}

/// Response body for [`Client::set_forwarding`] (wire method `setForwarding`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct SetForwardingResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub forwarding: Option<u64>,
}

/// Response body for [`Client::set_ivr`] (wire method `setIVR`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct SetIVRResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub ivr: Option<u64>,
}

/// Response body for [`Client::set_location`] (wire method `setLocation`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct SetLocationResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
}

/// Response body for [`Client::set_music_on_hold`] (wire method `setMusicOnHold`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct SetMusicOnHoldResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
}

/// Response body for [`Client::set_phonebook`] (wire method `setPhonebook`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct SetPhonebookResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub phonebook: Option<u64>,
}

/// Response body for [`Client::set_phonebook_group`] (wire method `setPhonebookGroup`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct SetPhonebookGroupResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub group: Option<u64>,
}

/// Response body for [`Client::set_queue`] (wire method `setQueue`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct SetQueueResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub queue: Option<u64>,
}

/// Response body for [`Client::set_recording`] (wire method `setRecording`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct SetRecordingResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub recording: Option<u64>,
}

/// Response body for [`Client::set_ring_group`] (wire method `setRingGroup`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct SetRingGroupResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub ring_group: Option<u64>,
}

/// Response body for [`Client::set_sip_uri`] (wire method `setSIPURI`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct SetSIPURIResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
}

/// Response body for [`Client::set_sms`] (wire method `setSMS`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct SetSMSResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number",
        rename = "sipuri"
    )]
    pub sip_uri: Option<u64>,
}

/// Response body for [`Client::set_static_member`] (wire method `setStaticMember`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct SetStaticMemberResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub member: Option<u64>,
}

/// Response body for [`Client::set_sub_account`] (wire method `setSubAccount`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct SetSubAccountResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
}

/// Response body for [`Client::set_time_condition`] (wire method `setTimeCondition`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct SetTimeConditionResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub timecondition: Option<u64>,
}

/// Response body for [`Client::set_voicemail`] (wire method `setVoicemail`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct SetVoicemailResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
}

/// Response body for [`Client::signup_client`] (wire method `signupClient`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct SignupClientResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_u64_from_string_or_number"
    )]
    pub client: Option<u64>,
}

/// Response body for [`Client::unconnect_did`] (wire method `unconnectDID`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct UnconnectDIDResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
}

/// Response body for [`Client::unconnect_fax`] (wire method `unconnectFAX`).
#[derive(Debug, Clone, Default, serde::Deserialize)]
pub struct UnconnectFAXResponse {
    #[serde(
        default,
        deserialize_with = "crate::responses::deserialize_opt_string_from_string_number_or_bool"
    )]
    pub status: Option<String>,
}

impl Client {
    /// \- Adds a Charge to a specific Reseller Client
    ///
    /// Call the `addCharge` API method and deserialize into [`AddChargeResponse`].
    pub async fn add_charge(&self, params: &AddChargeParams) -> Result<AddChargeResponse> {
        self.call("addCharge", params).await
    }

    /// Call the `addCharge` API method and return the raw JSON envelope.
    pub async fn add_charge_raw(&self, params: &AddChargeParams) -> Result<Value> {
        self.call_raw("addCharge", params).await
    }

    /// \- Add an invoice file to a portability process.
    ///
    /// Call the `addLNPFile` API method and deserialize into [`AddLNPFileResponse`].
    pub async fn add_lnp_file(&self, params: &AddLNPFileParams) -> Result<AddLNPFileResponse> {
        self.call("addLNPFile", params).await
    }

    /// Call the `addLNPFile` API method and return the raw JSON envelope.
    pub async fn add_lnp_file_raw(&self, params: &AddLNPFileParams) -> Result<Value> {
        self.call_raw("addLNPFile", params).await
    }

    /// \- Add one or more numbers to start a portability process.
    ///
    /// Call the `addLNPPort` API method and deserialize into [`AddLNPPortResponse`].
    pub async fn add_lnp_port(&self, params: &AddLNPPortParams) -> Result<AddLNPPortResponse> {
        self.call("addLNPPort", params).await
    }

    /// Call the `addLNPPort` API method and return the raw JSON envelope.
    pub async fn add_lnp_port_raw(&self, params: &AddLNPPortParams) -> Result<Value> {
        self.call_raw("addLNPPort", params).await
    }

    /// \- Add Member to a Conference
    ///
    /// Call the `addMemberToConference` API method and deserialize into [`AddMemberToConferenceResponse`].
    pub async fn add_member_to_conference(
        &self,
        params: &AddMemberToConferenceParams,
    ) -> Result<AddMemberToConferenceResponse> {
        self.call("addMemberToConference", params).await
    }

    /// Call the `addMemberToConference` API method and return the raw JSON envelope.
    pub async fn add_member_to_conference_raw(
        &self,
        params: &AddMemberToConferenceParams,
    ) -> Result<Value> {
        self.call_raw("addMemberToConference", params).await
    }

    /// \- Adds a Payment to a specific Reseller Client
    ///
    /// Call the `addPayment` API method and deserialize into [`AddPaymentResponse`].
    pub async fn add_payment(&self, params: &AddPaymentParams) -> Result<AddPaymentResponse> {
        self.call("addPayment", params).await
    }

    /// Call the `addPayment` API method and return the raw JSON envelope.
    pub async fn add_payment_raw(&self, params: &AddPaymentParams) -> Result<Value> {
        self.call_raw("addPayment", params).await
    }

    /// \- Assigns a Per Minute DID to a VPRI (Flat Rate DIDs can&rsquo;t be
    /// assigned)
    ///
    /// Call the `assignDIDvPRI` API method and deserialize into [`AssignDIDvPRIResponse`].
    pub async fn assign_did_vpri(
        &self,
        params: &AssignDIDvPRIParams,
    ) -> Result<AssignDIDvPRIResponse> {
        self.call("assignDIDvPRI", params).await
    }

    /// Call the `assignDIDvPRI` API method and return the raw JSON envelope.
    pub async fn assign_did_vpri_raw(&self, params: &AssignDIDvPRIParams) -> Result<Value> {
        self.call_raw("assignDIDvPRI", params).await
    }

    /// \- Backorder DID (CANADA) from a specific ratecenter and province.
    ///
    /// Call the `backOrderDIDCAN` API method and deserialize into [`BackOrderDIDCANResponse`].
    pub async fn back_order_did_can(
        &self,
        params: &BackOrderDIDCANParams,
    ) -> Result<BackOrderDIDCANResponse> {
        self.call("backOrderDIDCAN", params).await
    }

    /// Call the `backOrderDIDCAN` API method and return the raw JSON envelope.
    pub async fn back_order_did_can_raw(&self, params: &BackOrderDIDCANParams) -> Result<Value> {
        self.call_raw("backOrderDIDCAN", params).await
    }

    /// \- Backorder DID (USA) from a specific ratecenter and state.
    ///
    /// Call the `backOrderDIDUSA` API method and deserialize into [`BackOrderDIDUSAResponse`].
    pub async fn back_order_did_usa(
        &self,
        params: &BackOrderDIDUSAParams,
    ) -> Result<BackOrderDIDUSAResponse> {
        self.call("backOrderDIDUSA", params).await
    }

    /// Call the `backOrderDIDUSA` API method and return the raw JSON envelope.
    pub async fn back_order_did_usa_raw(&self, params: &BackOrderDIDUSAParams) -> Result<Value> {
        self.call_raw("backOrderDIDUSA", params).await
    }

    /// \- Deletes a specific DID from your Account.
    ///
    /// Call the `cancelDID` API method and deserialize into [`CancelDIDResponse`].
    pub async fn cancel_did(&self, params: &CancelDIDParams) -> Result<CancelDIDResponse> {
        self.call("cancelDID", params).await
    }

    /// Call the `cancelDID` API method and return the raw JSON envelope.
    pub async fn cancel_did_raw(&self, params: &CancelDIDParams) -> Result<Value> {
        self.call_raw("cancelDID", params).await
    }

    /// \- Deletes a specific Fax Number from your Account.
    ///
    /// Call the `cancelFaxNumber` API method and deserialize into [`CancelFAXNumberResponse`].
    pub async fn cancel_fax_number(
        &self,
        params: &CancelFAXNumberParams,
    ) -> Result<CancelFAXNumberResponse> {
        self.call("cancelFaxNumber", params).await
    }

    /// Call the `cancelFaxNumber` API method and return the raw JSON envelope.
    pub async fn cancel_fax_number_raw(&self, params: &CancelFAXNumberParams) -> Result<Value> {
        self.call_raw("cancelFaxNumber", params).await
    }

    /// \- Connects a specific DID to a specific Reseller Client Sub Account
    ///
    /// Call the `connectDID` API method and deserialize into [`ConnectDIDResponse`].
    pub async fn connect_did(&self, params: &ConnectDIDParams) -> Result<ConnectDIDResponse> {
        self.call("connectDID", params).await
    }

    /// Call the `connectDID` API method and return the raw JSON envelope.
    pub async fn connect_did_raw(&self, params: &ConnectDIDParams) -> Result<Value> {
        self.call_raw("connectDID", params).await
    }

    /// \- Connects a specific FAX DID to a specific Reseller Client Sub Account
    ///
    /// Call the `connectFAX` API method and deserialize into [`ConnectFAXResponse`].
    pub async fn connect_fax(&self, params: &ConnectFAXParams) -> Result<ConnectFAXResponse> {
        self.call("connectFAX", params).await
    }

    /// Call the `connectFAX` API method and return the raw JSON envelope.
    pub async fn connect_fax_raw(&self, params: &ConnectFAXParams) -> Result<Value> {
        self.call_raw("connectFAX", params).await
    }

    /// \- Adds a new Sub Account entry to your Account
    ///
    /// Call the `createSubAccount` API method and deserialize into [`CreateSubAccountResponse`].
    pub async fn create_sub_account(
        &self,
        params: &CreateSubAccountParams,
    ) -> Result<CreateSubAccountResponse> {
        self.call("createSubAccount", params).await
    }

    /// Call the `createSubAccount` API method and return the raw JSON envelope.
    pub async fn create_sub_account_raw(&self, params: &CreateSubAccountParams) -> Result<Value> {
        self.call_raw("createSubAccount", params).await
    }

    /// \- Adds a new Voicemail entry to your Account
    ///
    /// Call the `createVoicemail` API method and deserialize into [`CreateVoicemailResponse`].
    pub async fn create_voicemail(
        &self,
        params: &CreateVoicemailParams,
    ) -> Result<CreateVoicemailResponse> {
        self.call("createVoicemail", params).await
    }

    /// Call the `createVoicemail` API method and return the raw JSON envelope.
    pub async fn create_voicemail_raw(&self, params: &CreateVoicemailParams) -> Result<Value> {
        self.call_raw("createVoicemail", params).await
    }

    /// \- Deletes a specific Call Hunting from your Account.
    ///
    /// Call the `delCallHunting` API method and deserialize into [`DelCallHuntingResponse`].
    pub async fn del_call_hunting(
        &self,
        params: &DelCallHuntingParams,
    ) -> Result<DelCallHuntingResponse> {
        self.call("delCallHunting", params).await
    }

    /// Call the `delCallHunting` API method and return the raw JSON envelope.
    pub async fn del_call_hunting_raw(&self, params: &DelCallHuntingParams) -> Result<Value> {
        self.call_raw("delCallHunting", params).await
    }

    /// \- Deletes a specific Call Parking entry from your Account.
    ///
    /// Call the `delCallParking` API method and deserialize into [`DelCallParkingResponse`].
    pub async fn del_call_parking(
        &self,
        params: &DelCallParkingParams,
    ) -> Result<DelCallParkingResponse> {
        self.call("delCallParking", params).await
    }

    /// Call the `delCallParking` API method and return the raw JSON envelope.
    pub async fn del_call_parking_raw(&self, params: &DelCallParkingParams) -> Result<Value> {
        self.call_raw("delCallParking", params).await
    }

    /// \- Delete specific call recording, audio file and information related.
    ///
    /// Call the `delCallRecording` API method and deserialize into [`DelCallRecordingResponse`].
    pub async fn del_call_recording(
        &self,
        params: &DelCallRecordingParams,
    ) -> Result<DelCallRecordingResponse> {
        self.call("delCallRecording", params).await
    }

    /// Call the `delCallRecording` API method and return the raw JSON envelope.
    pub async fn del_call_recording_raw(&self, params: &DelCallRecordingParams) -> Result<Value> {
        self.call_raw("delCallRecording", params).await
    }

    /// \- Deletes a specific Callback from your Account.
    ///
    /// Call the `delCallback` API method and deserialize into [`DelCallbackResponse`].
    pub async fn del_callback(&self, params: &DelCallbackParams) -> Result<DelCallbackResponse> {
        self.call("delCallback", params).await
    }

    /// Call the `delCallback` API method and return the raw JSON envelope.
    pub async fn del_callback_raw(&self, params: &DelCallbackParams) -> Result<Value> {
        self.call_raw("delCallback", params).await
    }

    /// \- Deletes a specific CallerID Filtering from your Account.
    ///
    /// Call the `delCallerIDFiltering` API method and deserialize into [`DelCallerIDFilteringResponse`].
    pub async fn del_caller_id_filtering(
        &self,
        params: &DelCallerIDFilteringParams,
    ) -> Result<DelCallerIDFilteringResponse> {
        self.call("delCallerIDFiltering", params).await
    }

    /// Call the `delCallerIDFiltering` API method and return the raw JSON envelope.
    pub async fn del_caller_id_filtering_raw(
        &self,
        params: &DelCallerIDFilteringParams,
    ) -> Result<Value> {
        self.call_raw("delCallerIDFiltering", params).await
    }

    /// \- Deletes a specific reseller client from your Account.
    ///
    /// Call the `delClient` API method and deserialize into [`DelClientResponse`].
    pub async fn del_client(&self, params: &DelClientParams) -> Result<DelClientResponse> {
        self.call("delClient", params).await
    }

    /// Call the `delClient` API method and return the raw JSON envelope.
    pub async fn del_client_raw(&self, params: &DelClientParams) -> Result<Value> {
        self.call_raw("delClient", params).await
    }

    /// \- Deletes a specific Conference from your Account.
    ///
    /// Call the `delConference` API method and deserialize into [`DelConferenceResponse`].
    pub async fn del_conference(
        &self,
        params: &DelConferenceParams,
    ) -> Result<DelConferenceResponse> {
        self.call("delConference", params).await
    }

    /// Call the `delConference` API method and return the raw JSON envelope.
    pub async fn del_conference_raw(&self, params: &DelConferenceParams) -> Result<Value> {
        self.call_raw("delConference", params).await
    }

    /// \- Deletes a specific Member profile from your Account.
    ///
    /// Call the `delConferenceMember` API method and deserialize into [`DelConferenceMemberResponse`].
    pub async fn del_conference_member(
        &self,
        params: &DelConferenceMemberParams,
    ) -> Result<DelConferenceMemberResponse> {
        self.call("delConferenceMember", params).await
    }

    /// Call the `delConferenceMember` API method and return the raw JSON envelope.
    pub async fn del_conference_member_raw(
        &self,
        params: &DelConferenceMemberParams,
    ) -> Result<Value> {
        self.call_raw("delConferenceMember", params).await
    }

    /// \- Deletes a specific DISA from your Account.
    ///
    /// Call the `delDISA` API method and deserialize into [`DelDISAResponse`].
    pub async fn del_disa(&self, params: &DelDISAParams) -> Result<DelDISAResponse> {
        self.call("delDISA", params).await
    }

    /// Call the `delDISA` API method and return the raw JSON envelope.
    pub async fn del_disa_raw(&self, params: &DelDISAParams) -> Result<Value> {
        self.call_raw("delDISA", params).await
    }

    /// \- Deletes a specific "Email to Fax configuration" from your Account.
    ///
    /// Call the `delEmailToFax` API method and deserialize into [`DelEmailToFAXResponse`].
    pub async fn del_email_to_fax(
        &self,
        params: &DelEmailToFAXParams,
    ) -> Result<DelEmailToFAXResponse> {
        self.call("delEmailToFax", params).await
    }

    /// Call the `delEmailToFax` API method and return the raw JSON envelope.
    pub async fn del_email_to_fax_raw(&self, params: &DelEmailToFAXParams) -> Result<Value> {
        self.call_raw("delEmailToFax", params).await
    }

    /// \- Deletes a specific Fax Folder from your Account.
    ///
    /// Call the `delFaxFolder` API method and deserialize into [`DelFAXFolderResponse`].
    pub async fn del_fax_folder(
        &self,
        params: &DelFAXFolderParams,
    ) -> Result<DelFAXFolderResponse> {
        self.call("delFaxFolder", params).await
    }

    /// Call the `delFaxFolder` API method and return the raw JSON envelope.
    pub async fn del_fax_folder_raw(&self, params: &DelFAXFolderParams) -> Result<Value> {
        self.call_raw("delFaxFolder", params).await
    }

    /// \- Deletes a specific Forwarding from your Account.
    ///
    /// Call the `delForwarding` API method and deserialize into [`DelForwardingResponse`].
    pub async fn del_forwarding(
        &self,
        params: &DelForwardingParams,
    ) -> Result<DelForwardingResponse> {
        self.call("delForwarding", params).await
    }

    /// Call the `delForwarding` API method and return the raw JSON envelope.
    pub async fn del_forwarding_raw(&self, params: &DelForwardingParams) -> Result<Value> {
        self.call_raw("delForwarding", params).await
    }

    /// \- Deletes a specific IVR from your Account.
    ///
    /// Call the `delIVR` API method and deserialize into [`DelIVRResponse`].
    pub async fn del_ivr(&self, params: &DelIVRParams) -> Result<DelIVRResponse> {
        self.call("delIVR", params).await
    }

    /// Call the `delIVR` API method and return the raw JSON envelope.
    pub async fn del_ivr_raw(&self, params: &DelIVRParams) -> Result<Value> {
        self.call_raw("delIVR", params).await
    }

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

    /// Call the `delLocation` API method and return the raw JSON envelope.
    pub async fn del_location_raw(&self, params: &DelLocationParams) -> Result<Value> {
        self.call_raw("delLocation", params).await
    }

    /// \- Removes a member profile from a specific Conference from your Account
    ///
    /// Call the `delMemberFromConference` API method and deserialize into [`DelMemberFromConferenceResponse`].
    pub async fn del_member_from_conference(
        &self,
        params: &DelMemberFromConferenceParams,
    ) -> Result<DelMemberFromConferenceResponse> {
        self.call("delMemberFromConference", params).await
    }

    /// Call the `delMemberFromConference` API method and return the raw JSON envelope.
    pub async fn del_member_from_conference_raw(
        &self,
        params: &DelMemberFromConferenceParams,
    ) -> Result<Value> {
        self.call_raw("delMemberFromConference", params).await
    }

    /// \- Deletes all messages in all servers from a specific Voicemail from
    /// your Account
    ///
    /// Call the `delMessages` API method and deserialize into [`DelMessagesResponse`].
    pub async fn del_messages(&self, params: &DelMessagesParams) -> Result<DelMessagesResponse> {
        self.call("delMessages", params).await
    }

    /// Call the `delMessages` API method and return the raw JSON envelope.
    pub async fn del_messages_raw(&self, params: &DelMessagesParams) -> Result<Value> {
        self.call_raw("delMessages", params).await
    }

    /// \- Deletes a specific custom Music on Hold.
    ///
    /// Call the `delMusicOnHold` API method and deserialize into [`DelMusicOnHoldResponse`].
    pub async fn del_music_on_hold(
        &self,
        params: &DelMusicOnHoldParams,
    ) -> Result<DelMusicOnHoldResponse> {
        self.call("delMusicOnHold", params).await
    }

    /// Call the `delMusicOnHold` API method and return the raw JSON envelope.
    pub async fn del_music_on_hold_raw(&self, params: &DelMusicOnHoldParams) -> Result<Value> {
        self.call_raw("delMusicOnHold", params).await
    }

    /// \- Deletes a specific Phonebook from your Account.
    ///
    /// Call the `delPhonebook` API method and deserialize into [`DelPhonebookResponse`].
    pub async fn del_phonebook(&self, params: &DelPhonebookParams) -> Result<DelPhonebookResponse> {
        self.call("delPhonebook", params).await
    }

    /// Call the `delPhonebook` API method and return the raw JSON envelope.
    pub async fn del_phonebook_raw(&self, params: &DelPhonebookParams) -> Result<Value> {
        self.call_raw("delPhonebook", params).await
    }

    /// \- Deletes a specific Phonebook group from your Account.
    ///
    /// Call the `delPhonebookGroup` API method and deserialize into [`DelPhonebookGroupResponse`].
    pub async fn del_phonebook_group(
        &self,
        params: &DelPhonebookGroupParams,
    ) -> Result<DelPhonebookGroupResponse> {
        self.call("delPhonebookGroup", params).await
    }

    /// Call the `delPhonebookGroup` API method and return the raw JSON envelope.
    pub async fn del_phonebook_group_raw(&self, params: &DelPhonebookGroupParams) -> Result<Value> {
        self.call_raw("delPhonebookGroup", params).await
    }

    /// \- Deletes a specific Queue from your Account.
    ///
    /// Call the `delQueue` API method and deserialize into [`DelQueueResponse`].
    pub async fn del_queue(&self, params: &DelQueueParams) -> Result<DelQueueResponse> {
        self.call("delQueue", params).await
    }

    /// Call the `delQueue` API method and return the raw JSON envelope.
    pub async fn del_queue_raw(&self, params: &DelQueueParams) -> Result<Value> {
        self.call_raw("delQueue", params).await
    }

    /// \- Deletes a specific Recording from your Account.
    ///
    /// Call the `delRecording` API method and deserialize into [`DelRecordingResponse`].
    pub async fn del_recording(&self, params: &DelRecordingParams) -> Result<DelRecordingResponse> {
        self.call("delRecording", params).await
    }

    /// Call the `delRecording` API method and return the raw JSON envelope.
    pub async fn del_recording_raw(&self, params: &DelRecordingParams) -> Result<Value> {
        self.call_raw("delRecording", params).await
    }

    /// \- Deletes a specific Ring Group from your Account.
    ///
    /// Call the `delRingGroup` API method and deserialize into [`DelRingGroupResponse`].
    pub async fn del_ring_group(
        &self,
        params: &DelRingGroupParams,
    ) -> Result<DelRingGroupResponse> {
        self.call("delRingGroup", params).await
    }

    /// Call the `delRingGroup` API method and return the raw JSON envelope.
    pub async fn del_ring_group_raw(&self, params: &DelRingGroupParams) -> Result<Value> {
        self.call_raw("delRingGroup", params).await
    }

    /// \- Deletes a specific SIP URI from your Account.
    ///
    /// Call the `delSIPURI` API method and deserialize into [`DelSIPURIResponse`].
    pub async fn del_sip_uri(&self, params: &DelSIPURIParams) -> Result<DelSIPURIResponse> {
        self.call("delSIPURI", params).await
    }

    /// Call the `delSIPURI` API method and return the raw JSON envelope.
    pub async fn del_sip_uri_raw(&self, params: &DelSIPURIParams) -> Result<Value> {
        self.call_raw("delSIPURI", params).await
    }

    /// \- Deletes a specific Static Member from Queue.
    ///
    /// Call the `delStaticMember` API method and deserialize into [`DelStaticMemberResponse`].
    pub async fn del_static_member(
        &self,
        params: &DelStaticMemberParams,
    ) -> Result<DelStaticMemberResponse> {
        self.call("delStaticMember", params).await
    }

    /// Call the `delStaticMember` API method and return the raw JSON envelope.
    pub async fn del_static_member_raw(&self, params: &DelStaticMemberParams) -> Result<Value> {
        self.call_raw("delStaticMember", params).await
    }

    /// \- Deletes a specific Sub Account from your Account
    ///
    /// Call the `delSubAccount` API method and deserialize into [`DelSubAccountResponse`].
    pub async fn del_sub_account(
        &self,
        params: &DelSubAccountParams,
    ) -> Result<DelSubAccountResponse> {
        self.call("delSubAccount", params).await
    }

    /// Call the `delSubAccount` API method and return the raw JSON envelope.
    pub async fn del_sub_account_raw(&self, params: &DelSubAccountParams) -> Result<Value> {
        self.call_raw("delSubAccount", params).await
    }

    /// \- Deletes a specific Time Condition from your Account.
    ///
    /// Call the `delTimeCondition` API method and deserialize into [`DelTimeConditionResponse`].
    pub async fn del_time_condition(
        &self,
        params: &DelTimeConditionParams,
    ) -> Result<DelTimeConditionResponse> {
        self.call("delTimeCondition", params).await
    }

    /// Call the `delTimeCondition` API method and return the raw JSON envelope.
    pub async fn del_time_condition_raw(&self, params: &DelTimeConditionParams) -> Result<Value> {
        self.call_raw("delTimeCondition", params).await
    }

    /// \- Deletes a specific Voicemail from your Account
    ///
    /// Call the `delVoicemail` API method and deserialize into [`DelVoicemailResponse`].
    pub async fn del_voicemail(&self, params: &DelVoicemailParams) -> Result<DelVoicemailResponse> {
        self.call("delVoicemail", params).await
    }

    /// Call the `delVoicemail` API method and return the raw JSON envelope.
    pub async fn del_voicemail_raw(&self, params: &DelVoicemailParams) -> Result<Value> {
        self.call_raw("delVoicemail", params).await
    }

    /// \- Deletes a specific Fax Message from your Account.
    ///
    /// Call the `deleteFaxMessage` API method and deserialize into [`DeleteFAXMessageResponse`].
    pub async fn delete_fax_message(
        &self,
        params: &DeleteFAXMessageParams,
    ) -> Result<DeleteFAXMessageResponse> {
        self.call("deleteFaxMessage", params).await
    }

    /// Call the `deleteFaxMessage` API method and return the raw JSON envelope.
    pub async fn delete_fax_message_raw(&self, params: &DeleteFAXMessageParams) -> Result<Value> {
        self.call_raw("deleteFaxMessage", params).await
    }

    /// \- Deletes a specific MMS from your Account.
    ///
    /// Call the `deleteMMS` API method and deserialize into [`DeleteMMSResponse`].
    pub async fn delete_mms(&self, params: &DeleteMMSParams) -> Result<DeleteMMSResponse> {
        self.call("deleteMMS", params).await
    }

    /// Call the `deleteMMS` API method and return the raw JSON envelope.
    pub async fn delete_mms_raw(&self, params: &DeleteMMSParams) -> Result<Value> {
        self.call_raw("deleteMMS", params).await
    }

    /// \- Deletes a specific SMS from your Account.
    ///
    /// Call the `deleteSMS` API method and deserialize into [`DeleteSMSResponse`].
    pub async fn delete_sms(&self, params: &DeleteSMSParams) -> Result<DeleteSMSResponse> {
        self.call("deleteSMS", params).await
    }

    /// Call the `deleteSMS` API method and return the raw JSON envelope.
    pub async fn delete_sms_raw(&self, params: &DeleteSMSParams) -> Result<Value> {
        self.call_raw("deleteSMS", params).await
    }

    /// \- Retrieves a list of e911 Address Types if no additional parameter is
    /// provided.
    /// \- Retrieves a specific e911 Address Type if an Address code is provided.
    ///
    /// Call the `e911AddressTypes` API method and deserialize into [`E911AddressTypesResponse`].
    pub async fn e911_address_types(
        &self,
        params: &E911AddressTypesParams,
    ) -> Result<E911AddressTypesResponse> {
        self.call("e911AddressTypes", params).await
    }

    /// Call the `e911AddressTypes` API method and return the raw JSON envelope.
    pub async fn e911_address_types_raw(&self, params: &E911AddressTypesParams) -> Result<Value> {
        self.call_raw("e911AddressTypes", params).await
    }

    /// \- Cancel the e911 Service from a specific DID.
    ///
    /// Call the `e911Cancel` API method and deserialize into [`E911CancelResponse`].
    pub async fn e911_cancel(&self, params: &E911CancelParams) -> Result<E911CancelResponse> {
        self.call("e911Cancel", params).await
    }

    /// Call the `e911Cancel` API method and return the raw JSON envelope.
    pub async fn e911_cancel_raw(&self, params: &E911CancelParams) -> Result<Value> {
        self.call_raw("e911Cancel", params).await
    }

    /// \- Retrieves the e911 information from a specific DID.
    ///
    /// Call the `e911Info` API method and deserialize into [`E911InfoResponse`].
    pub async fn e911_info(&self, params: &E911InfoParams) -> Result<E911InfoResponse> {
        self.call("e911Info", params).await
    }

    /// Call the `e911Info` API method and return the raw JSON envelope.
    pub async fn e911_info_raw(&self, params: &E911InfoParams) -> Result<Value> {
        self.call_raw("e911Info", params).await
    }

    /// \- Subscribes your DID to the e911 Emergency Services.
    ///
    /// Call the `e911Provision` API method and deserialize into [`E911ProvisionResponse`].
    pub async fn e911_provision(
        &self,
        params: &E911ProvisionParams,
    ) -> Result<E911ProvisionResponse> {
        self.call("e911Provision", params).await
    }

    /// Call the `e911Provision` API method and return the raw JSON envelope.
    pub async fn e911_provision_raw(&self, params: &E911ProvisionParams) -> Result<Value> {
        self.call_raw("e911Provision", params).await
    }

    /// \- Subscribes your DID to the e911 Emergency Services.
    /// \- All e911 information will be validated by the VoIP.ms staff.
    ///
    /// Call the `e911ProvisionManually` API method and deserialize into [`E911ProvisionManuallyResponse`].
    pub async fn e911_provision_manually(
        &self,
        params: &E911ProvisionManuallyParams,
    ) -> Result<E911ProvisionManuallyResponse> {
        self.call("e911ProvisionManually", params).await
    }

    /// Call the `e911ProvisionManually` API method and return the raw JSON envelope.
    pub async fn e911_provision_manually_raw(
        &self,
        params: &E911ProvisionManuallyParams,
    ) -> Result<Value> {
        self.call_raw("e911ProvisionManually", params).await
    }

    /// \- Updates the Information from your e911 Emergency Services
    /// Subscription.
    ///
    /// Call the `e911Update` API method and deserialize into [`E911UpdateResponse`].
    pub async fn e911_update(&self, params: &E911UpdateParams) -> Result<E911UpdateResponse> {
        self.call("e911Update", params).await
    }

    /// Call the `e911Update` API method and return the raw JSON envelope.
    pub async fn e911_update_raw(&self, params: &E911UpdateParams) -> Result<Value> {
        self.call_raw("e911Update", params).await
    }

    /// \- Validates your e911 information in order to start your e911 Emergency
    /// Services Subscription.
    ///
    /// Call the `e911Validate` API method and deserialize into [`E911ValidateResponse`].
    pub async fn e911_validate(&self, params: &E911ValidateParams) -> Result<E911ValidateResponse> {
        self.call("e911Validate", params).await
    }

    /// Call the `e911Validate` API method and return the raw JSON envelope.
    pub async fn e911_validate_raw(&self, params: &E911ValidateParams) -> Result<Value> {
        self.call_raw("e911Validate", params).await
    }

    /// \- Retrieves a list of Allowed Codecs if no additional parameter is
    /// provided.
    /// \- Retrieves a specific Allowed Codec if a codec code is provided.
    ///
    /// Call the `getAllowedCodecs` API method and deserialize into [`GetAllowedCodecsResponse`].
    pub async fn get_allowed_codecs(
        &self,
        params: &GetAllowedCodecsParams,
    ) -> Result<GetAllowedCodecsResponse> {
        self.call("getAllowedCodecs", params).await
    }

    /// Call the `getAllowedCodecs` API method and return the raw JSON envelope.
    pub async fn get_allowed_codecs_raw(&self, params: &GetAllowedCodecsParams) -> Result<Value> {
        self.call_raw("getAllowedCodecs", params).await
    }

    /// \- Retrieves a list of Authentication Types if no additional parameter is
    /// provided.
    /// \- Retrieves a specific Authentication Type if an auth type code is
    /// provided.
    ///
    /// Call the `getAuthTypes` API method and deserialize into [`GetAuthTypesResponse`].
    pub async fn get_auth_types(
        &self,
        params: &GetAuthTypesParams,
    ) -> Result<GetAuthTypesResponse> {
        self.call("getAuthTypes", params).await
    }

    /// Call the `getAuthTypes` API method and return the raw JSON envelope.
    pub async fn get_auth_types_raw(&self, params: &GetAuthTypesParams) -> Result<Value> {
        self.call_raw("getAuthTypes", params).await
    }

    /// \- Retrieves a list of backorder DIDs if no additional parameter is
    /// provided.
    /// \- Retrieves a specific backorder DID if a backorder DID code is
    /// provided.
    ///
    /// Call the `getBackOrders` API method and deserialize into [`GetBackOrdersResponse`].
    pub async fn get_back_orders(
        &self,
        params: &GetBackOrdersParams,
    ) -> Result<GetBackOrdersResponse> {
        self.call("getBackOrders", params).await
    }

    /// Call the `getBackOrders` API method and return the raw JSON envelope.
    pub async fn get_back_orders_raw(&self, params: &GetBackOrdersParams) -> Result<Value> {
        self.call_raw("getBackOrders", params).await
    }

    /// \- Retrieves Balance for your Account if no additional parameter is
    /// provided.
    /// \- Retrieves Balance and Calls Statistics for your Account if "advanced"
    /// parameter is true.
    ///
    /// Call the `getBalance` API method and deserialize into [`GetBalanceResponse`].
    pub async fn get_balance(&self, params: &GetBalanceParams) -> Result<GetBalanceResponse> {
        self.call("getBalance", params).await
    }

    /// Call the `getBalance` API method and return the raw JSON envelope.
    pub async fn get_balance_raw(&self, params: &GetBalanceParams) -> Result<Value> {
        self.call_raw("getBalance", params).await
    }

    /// \- Retrieves a list of Balance Management Options if no additional
    /// parameter is provided.
    /// \- Retrieves a specific Balance Management Option if a code is provided.
    ///
    /// Call the `getBalanceManagement` API method and deserialize into [`GetBalanceManagementResponse`].
    pub async fn get_balance_management(
        &self,
        params: &GetBalanceManagementParams,
    ) -> Result<GetBalanceManagementResponse> {
        self.call("getBalanceManagement", params).await
    }

    /// Call the `getBalanceManagement` API method and return the raw JSON envelope.
    pub async fn get_balance_management_raw(
        &self,
        params: &GetBalanceManagementParams,
    ) -> Result<Value> {
        self.call_raw("getBalanceManagement", params).await
    }

    /// \- Retrieves the Call Detail Records of all your calls.
    ///
    /// Call the `getCDR` API method and deserialize into [`GetCDRResponse`].
    ///
    /// A `timezone` zone is resolved to the numeric UTC offset the wire
    /// expects, at the query start date; a zone that cannot be resolved
    /// is [`Error::InvalidParams`](crate::Error::InvalidParams).
    pub async fn get_cdr(&self, params: &GetCDRParams) -> Result<GetCDRResponse> {
        self.call("getCDR", &GetCDRParamsWire::try_from(params)?)
            .await
    }

    /// Call the `getCDR` API method and return the raw JSON envelope.
    ///
    /// A `timezone` zone is resolved to the numeric UTC offset the wire
    /// expects, at the query start date; a zone that cannot be resolved
    /// is [`Error::InvalidParams`](crate::Error::InvalidParams).
    pub async fn get_cdr_raw(&self, params: &GetCDRParams) -> Result<Value> {
        self.call_raw("getCDR", &GetCDRParamsWire::try_from(params)?)
            .await
    }

    /// \- Retrieves all Sub Accounts if no additional parameter is provided.
    /// \- Retrieves Reseller Client Accounts if Reseller Client ID is provided.
    ///
    /// Call the `getCallAccounts` API method and deserialize into [`GetCallAccountsResponse`].
    pub async fn get_call_accounts(
        &self,
        params: &GetCallAccountsParams,
    ) -> Result<GetCallAccountsResponse> {
        self.call("getCallAccounts", params).await
    }

    /// Call the `getCallAccounts` API method and return the raw JSON envelope.
    pub async fn get_call_accounts_raw(&self, params: &GetCallAccountsParams) -> Result<Value> {
        self.call_raw("getCallAccounts", params).await
    }

    /// \- Retrieves a list of Call Billing Options.
    ///
    /// Call the `getCallBilling` API method and deserialize into [`GetCallBillingResponse`].
    pub async fn get_call_billing(
        &self,
        params: &GetCallBillingParams,
    ) -> Result<GetCallBillingResponse> {
        self.call("getCallBilling", params).await
    }

    /// Call the `getCallBilling` API method and return the raw JSON envelope.
    pub async fn get_call_billing_raw(&self, params: &GetCallBillingParams) -> Result<Value> {
        self.call_raw("getCallBilling", params).await
    }

    /// \- Retrieves a list of Call Huntings if no additional parameter is
    /// provided.
    /// \- Retrieves a specific Call Huntings if a Call Hunting code is provided.
    ///
    /// Call the `getCallHuntings` API method and deserialize into [`GetCallHuntingsResponse`].
    pub async fn get_call_huntings(
        &self,
        params: &GetCallHuntingsParams,
    ) -> Result<GetCallHuntingsResponse> {
        self.call("getCallHuntings", params).await
    }

    /// Call the `getCallHuntings` API method and return the raw JSON envelope.
    pub async fn get_call_huntings_raw(&self, params: &GetCallHuntingsParams) -> Result<Value> {
        self.call_raw("getCallHuntings", params).await
    }

    /// \- Retrieves all Call Parking entries if no additional parameter is
    /// provided.
    /// \- Retrieves a specific Parking entry if a Call Parking ID is provided.
    ///
    /// Call the `getCallParking` API method and deserialize into [`GetCallParkingResponse`].
    pub async fn get_call_parking(
        &self,
        params: &GetCallParkingParams,
    ) -> Result<GetCallParkingResponse> {
        self.call("getCallParking", params).await
    }

    /// Call the `getCallParking` API method and return the raw JSON envelope.
    pub async fn get_call_parking_raw(&self, params: &GetCallParkingParams) -> Result<Value> {
        self.call_raw("getCallParking", params).await
    }

    /// \- Retrieves one especific call recording information, including the
    /// recording file on mp3 format.
    ///
    /// Call the `getCallRecording` API method and deserialize into [`GetCallRecordingResponse`].
    pub async fn get_call_recording(
        &self,
        params: &GetCallRecordingParams,
    ) -> Result<GetCallRecordingResponse> {
        self.call("getCallRecording", params).await
    }

    /// Call the `getCallRecording` API method and return the raw JSON envelope.
    pub async fn get_call_recording_raw(&self, params: &GetCallRecordingParams) -> Result<Value> {
        self.call_raw("getCallRecording", params).await
    }

    /// \- Retrieves all call recordings related to account.
    ///
    /// Call the `getCallRecordings` API method and deserialize into [`GetCallRecordingsResponse`].
    pub async fn get_call_recordings(
        &self,
        params: &GetCallRecordingsParams,
    ) -> Result<GetCallRecordingsResponse> {
        self.call("getCallRecordings", params).await
    }

    /// Call the `getCallRecordings` API method and return the raw JSON envelope.
    pub async fn get_call_recordings_raw(&self, params: &GetCallRecordingsParams) -> Result<Value> {
        self.call_raw("getCallRecordings", params).await
    }

    /// \- Retrieves all Call Transcriptions if no additional parameter is
    /// provided.
    ///
    /// Call the `getCallTranscriptions` API method and deserialize into [`GetCallTranscriptionsResponse`].
    pub async fn get_call_transcriptions(
        &self,
        params: &GetCallTranscriptionsParams,
    ) -> Result<GetCallTranscriptionsResponse> {
        self.call("getCallTranscriptions", params).await
    }

    /// Call the `getCallTranscriptions` API method and return the raw JSON envelope.
    pub async fn get_call_transcriptions_raw(
        &self,
        params: &GetCallTranscriptionsParams,
    ) -> Result<Value> {
        self.call_raw("getCallTranscriptions", params).await
    }

    /// \- Retrieves a list of Call Types and All DIDs if no additional parameter
    /// is provided.
    /// \- Retrieves a list of Call Types and Reseller Client DIDs if a Reseller
    /// Client ID is provided.
    ///
    /// Call the `getCallTypes` API method and deserialize into [`GetCallTypesResponse`].
    pub async fn get_call_types(
        &self,
        params: &GetCallTypesParams,
    ) -> Result<GetCallTypesResponse> {
        self.call("getCallTypes", params).await
    }

    /// Call the `getCallTypes` API method and return the raw JSON envelope.
    pub async fn get_call_types_raw(&self, params: &GetCallTypesParams) -> Result<Value> {
        self.call_raw("getCallTypes", params).await
    }

    /// \- Retrieves a list of Callbacks if no additional parameter is provided.
    /// \- Retrieves a specific Callback if a Callback code is provided.
    ///
    /// Call the `getCallbacks` API method and deserialize into [`GetCallbacksResponse`].
    pub async fn get_callbacks(&self, params: &GetCallbacksParams) -> Result<GetCallbacksResponse> {
        self.call("getCallbacks", params).await
    }

    /// Call the `getCallbacks` API method and return the raw JSON envelope.
    pub async fn get_callbacks_raw(&self, params: &GetCallbacksParams) -> Result<Value> {
        self.call_raw("getCallbacks", params).await
    }

    /// \- Retrieves a list of CallerID Filterings if no additional parameter is
    /// provided.
    /// \- Retrieves a specific CallerID Filtering if a CallerID Filtering code
    /// is provided.
    ///
    /// Call the `getCallerIDFiltering` API method and deserialize into [`GetCallerIDFilteringResponse`].
    pub async fn get_caller_id_filtering(
        &self,
        params: &GetCallerIDFilteringParams,
    ) -> Result<GetCallerIDFilteringResponse> {
        self.call("getCallerIDFiltering", params).await
    }

    /// Call the `getCallerIDFiltering` API method and return the raw JSON envelope.
    pub async fn get_caller_id_filtering_raw(
        &self,
        params: &GetCallerIDFilteringParams,
    ) -> Result<Value> {
        self.call_raw("getCallerIDFiltering", params).await
    }

    /// \- Retrieves a list of Carriers for Vanity Numbers if no additional
    /// parameter is provided.
    /// \- Retrieves a specific Carrier for Vanity Numbers if a carrier code is
    /// provided.
    ///
    /// Call the `getCarriers` API method and deserialize into [`GetCarriersResponse`].
    pub async fn get_carriers(&self, params: &GetCarriersParams) -> Result<GetCarriersResponse> {
        self.call("getCarriers", params).await
    }

    /// Call the `getCarriers` API method and return the raw JSON envelope.
    pub async fn get_carriers_raw(&self, params: &GetCarriersParams) -> Result<Value> {
        self.call_raw("getCarriers", params).await
    }

    /// \- Retrieves Charges made to a specific Reseller Client.
    ///
    /// Call the `getCharges` API method and deserialize into [`GetChargesResponse`].
    pub async fn get_charges(&self, params: &GetChargesParams) -> Result<GetChargesResponse> {
        self.call("getCharges", params).await
    }

    /// Call the `getCharges` API method and return the raw JSON envelope.
    pub async fn get_charges_raw(&self, params: &GetChargesParams) -> Result<Value> {
        self.call_raw("getCharges", params).await
    }

    /// \- Retrieves a list of Packages for a specific Reseller Client.
    ///
    /// Call the `getClientPackages` API method and deserialize into [`GetClientPackagesResponse`].
    pub async fn get_client_packages(
        &self,
        params: &GetClientPackagesParams,
    ) -> Result<GetClientPackagesResponse> {
        self.call("getClientPackages", params).await
    }

    /// Call the `getClientPackages` API method and return the raw JSON envelope.
    pub async fn get_client_packages_raw(&self, params: &GetClientPackagesParams) -> Result<Value> {
        self.call_raw("getClientPackages", params).await
    }

    /// \- Retrieves the Threshold Information for a specific Reseller Client.
    ///
    /// Call the `getClientThreshold` API method and deserialize into [`GetClientThresholdResponse`].
    pub async fn get_client_threshold(
        &self,
        params: &GetClientThresholdParams,
    ) -> Result<GetClientThresholdResponse> {
        self.call("getClientThreshold", params).await
    }

    /// Call the `getClientThreshold` API method and return the raw JSON envelope.
    pub async fn get_client_threshold_raw(
        &self,
        params: &GetClientThresholdParams,
    ) -> Result<Value> {
        self.call_raw("getClientThreshold", params).await
    }

    /// \- Retrieves a list of all Clients if no additional parameter is
    /// provided.- Retrieves a specific Reseller Client if a Reseller Client ID
    /// is provided.
    /// \- Retrieves a specific Reseller Client if a Reseller Client e-mail is
    /// provided.
    ///
    /// Call the `getClients` API method and deserialize into [`GetClientsResponse`].
    pub async fn get_clients(&self, params: &GetClientsParams) -> Result<GetClientsResponse> {
        self.call("getClients", params).await
    }

    /// Call the `getClients` API method and return the raw JSON envelope.
    pub async fn get_clients_raw(&self, params: &GetClientsParams) -> Result<Value> {
        self.call_raw("getClients", params).await
    }

    /// \- Retrieves a list of Conferences if no additional parameter is
    /// provided.
    /// \- Retrieves a specific Conference if a conference code is provided.
    ///
    /// Call the `getConference` API method and deserialize into [`GetConferenceResponse`].
    pub async fn get_conference(
        &self,
        params: &GetConferenceParams,
    ) -> Result<GetConferenceResponse> {
        self.call("getConference", params).await
    }

    /// Call the `getConference` API method and return the raw JSON envelope.
    pub async fn get_conference_raw(&self, params: &GetConferenceParams) -> Result<Value> {
        self.call_raw("getConference", params).await
    }

    /// \- Retrieves a list of Member profiles if no additional parameter is
    /// provided.
    /// \- Retrieves a specific member if a member code is provided.
    ///
    /// Call the `getConferenceMembers` API method and deserialize into [`GetConferenceMembersResponse`].
    pub async fn get_conference_members(
        &self,
        params: &GetConferenceMembersParams,
    ) -> Result<GetConferenceMembersResponse> {
        self.call("getConferenceMembers", params).await
    }

    /// Call the `getConferenceMembers` API method and return the raw JSON envelope.
    pub async fn get_conference_members_raw(
        &self,
        params: &GetConferenceMembersParams,
    ) -> Result<Value> {
        self.call_raw("getConferenceMembers", params).await
    }

    /// \- Retrieves a specific Recording File data in Base64 format.
    ///
    /// Call the `getConferenceRecordingFile` API method and deserialize into [`GetConferenceRecordingFileResponse`].
    pub async fn get_conference_recording_file(
        &self,
        params: &GetConferenceRecordingFileParams,
    ) -> Result<GetConferenceRecordingFileResponse> {
        self.call("getConferenceRecordingFile", params).await
    }

    /// Call the `getConferenceRecordingFile` API method and return the raw JSON envelope.
    pub async fn get_conference_recording_file_raw(
        &self,
        params: &GetConferenceRecordingFileParams,
    ) -> Result<Value> {
        self.call_raw("getConferenceRecordingFile", params).await
    }

    /// \- Retrieves a list of recordings of a specific conference.
    ///
    /// Call the `getConferenceRecordings` API method and deserialize into [`GetConferenceRecordingsResponse`].
    pub async fn get_conference_recordings(
        &self,
        params: &GetConferenceRecordingsParams,
    ) -> Result<GetConferenceRecordingsResponse> {
        self.call("getConferenceRecordings", params).await
    }

    /// Call the `getConferenceRecordings` API method and return the raw JSON envelope.
    pub async fn get_conference_recordings_raw(
        &self,
        params: &GetConferenceRecordingsParams,
    ) -> Result<Value> {
        self.call_raw("getConferenceRecordings", params).await
    }

    /// \- Retrieves a list of Countries if no additional parameter is provided.
    /// \- Retrieves a specific Country if a country code is provided.
    ///
    /// Call the `getCountries` API method and deserialize into [`GetCountriesResponse`].
    pub async fn get_countries(&self, params: &GetCountriesParams) -> Result<GetCountriesResponse> {
        self.call("getCountries", params).await
    }

    /// Call the `getCountries` API method and return the raw JSON envelope.
    pub async fn get_countries_raw(&self, params: &GetCountriesParams) -> Result<Value> {
        self.call_raw("getCountries", params).await
    }

    /// \- Retrieves a list of Countries for International DIDs if no country
    /// code is provided.
    /// \- Retrieves a specific Country for International DIDs if a country code
    /// is provided.
    ///
    /// Call the `getDIDCountries` API method and deserialize into [`GetDIDCountriesResponse`].
    pub async fn get_did_countries(
        &self,
        params: &GetDIDCountriesParams,
    ) -> Result<GetDIDCountriesResponse> {
        self.call("getDIDCountries", params).await
    }

    /// Call the `getDIDCountries` API method and return the raw JSON envelope.
    pub async fn get_did_countries_raw(&self, params: &GetDIDCountriesParams) -> Result<Value> {
        self.call_raw("getDIDCountries", params).await
    }

    /// \- Retrives a list of Canadian DIDs by Province and Ratecenter.
    ///
    /// Call the `getDIDsCAN` API method and deserialize into [`GetDIDsCANResponse`].
    pub async fn get_dids_can(&self, params: &GetDIDsCANParams) -> Result<GetDIDsCANResponse> {
        self.call("getDIDsCAN", params).await
    }

    /// Call the `getDIDsCAN` API method and return the raw JSON envelope.
    pub async fn get_dids_can_raw(&self, params: &GetDIDsCANParams) -> Result<Value> {
        self.call_raw("getDIDsCAN", params).await
    }

    /// \- Retrieves information from all your DIDs if no additional parameter is
    /// provided.
    /// \- Retrieves information from Reseller Client's DIDs if a Reseller Client
    /// ID is provided.
    /// \- Retrieves information from Sub Account's DIDs if a Sub Accunt is
    /// provided.
    /// \- Retrieves information from a specific DID if a DID Number is provided.
    /// \- Retrieves SMS information from a specific DID if the SMS is available.
    ///
    /// Call the `getDIDsInfo` API method and deserialize into [`GetDIDsInfoResponse`].
    pub async fn get_dids_info(&self, params: &GetDIDsInfoParams) -> Result<GetDIDsInfoResponse> {
        self.call("getDIDsInfo", params).await
    }

    /// Call the `getDIDsInfo` API method and return the raw JSON envelope.
    pub async fn get_dids_info_raw(&self, params: &GetDIDsInfoParams) -> Result<Value> {
        self.call_raw("getDIDsInfo", params).await
    }

    /// \- Retrieves a list of International Geographic DIDs by Country.
    ///
    /// Call the `getDIDsInternationalGeographic` API method and deserialize into [`GetDIDsInternationalGeographicResponse`].
    pub async fn get_dids_international_geographic(
        &self,
        params: &GetDIDsInternationalGeographicParams,
    ) -> Result<GetDIDsInternationalGeographicResponse> {
        self.call("getDIDsInternationalGeographic", params).await
    }

    /// Call the `getDIDsInternationalGeographic` API method and return the raw JSON envelope.
    pub async fn get_dids_international_geographic_raw(
        &self,
        params: &GetDIDsInternationalGeographicParams,
    ) -> Result<Value> {
        self.call_raw("getDIDsInternationalGeographic", params)
            .await
    }

    /// \- Retrieves a list of International National DIDs by Country.
    ///
    /// Call the `getDIDsInternationalNational` API method and deserialize into [`GetDIDsInternationalNationalResponse`].
    pub async fn get_dids_international_national(
        &self,
        params: &GetDIDsInternationalNationalParams,
    ) -> Result<GetDIDsInternationalNationalResponse> {
        self.call("getDIDsInternationalNational", params).await
    }

    /// Call the `getDIDsInternationalNational` API method and return the raw JSON envelope.
    pub async fn get_dids_international_national_raw(
        &self,
        params: &GetDIDsInternationalNationalParams,
    ) -> Result<Value> {
        self.call_raw("getDIDsInternationalNational", params).await
    }

    /// \- Retrieves a list of International TollFree DIDs by Country.
    ///
    /// Call the `getDIDsInternationalTollFree` API method and deserialize into [`GetDIDsInternationalTollFreeResponse`].
    pub async fn get_dids_international_toll_free(
        &self,
        params: &GetDIDsInternationalTollFreeParams,
    ) -> Result<GetDIDsInternationalTollFreeResponse> {
        self.call("getDIDsInternationalTollFree", params).await
    }

    /// Call the `getDIDsInternationalTollFree` API method and return the raw JSON envelope.
    pub async fn get_dids_international_toll_free_raw(
        &self,
        params: &GetDIDsInternationalTollFreeParams,
    ) -> Result<Value> {
        self.call_raw("getDIDsInternationalTollFree", params).await
    }

    /// \- Retrives a list of USA DIDs by State and Ratecenter.
    ///
    /// Call the `getDIDsUSA` API method and deserialize into [`GetDIDsUSAResponse`].
    pub async fn get_dids_usa(&self, params: &GetDIDsUSAParams) -> Result<GetDIDsUSAResponse> {
        self.call("getDIDsUSA", params).await
    }

    /// Call the `getDIDsUSA` API method and return the raw JSON envelope.
    pub async fn get_dids_usa_raw(&self, params: &GetDIDsUSAParams) -> Result<Value> {
        self.call_raw("getDIDsUSA", params).await
    }

    /// \- Retrives the list of DIDs assigned to the VPRI.
    ///
    /// Call the `getDIDvPRI` API method and deserialize into [`GetDIDvPRIResponse`].
    pub async fn get_did_vpri(&self, params: &GetDIDvPRIParams) -> Result<GetDIDvPRIResponse> {
        self.call("getDIDvPRI", params).await
    }

    /// Call the `getDIDvPRI` API method and return the raw JSON envelope.
    pub async fn get_did_vpri_raw(&self, params: &GetDIDvPRIParams) -> Result<Value> {
        self.call_raw("getDIDvPRI", params).await
    }

    /// \- Retrieves a list of DISAs if no additional parameter is provided.
    /// \- Retrieves a specific DISA if a DISA code is provided.
    ///
    /// Call the `getDISAs` API method and deserialize into [`GetDISAsResponse`].
    pub async fn get_disas(&self, params: &GetDISAsParams) -> Result<GetDISAsResponse> {
        self.call("getDISAs", params).await
    }

    /// Call the `getDISAs` API method and return the raw JSON envelope.
    pub async fn get_disas_raw(&self, params: &GetDISAsParams) -> Result<Value> {
        self.call_raw("getDISAs", params).await
    }

    /// \- Retrieves a list of DTMF Modes if no additional parameter is provided.
    /// \- Retrieves a specific DTMF Mode if a DTMF mode code is provided.
    ///
    /// Call the `getDTMFModes` API method and deserialize into [`GetDTMFModesResponse`].
    pub async fn get_dtmf_modes(
        &self,
        params: &GetDTMFModesParams,
    ) -> Result<GetDTMFModesResponse> {
        self.call("getDTMFModes", params).await
    }

    /// Call the `getDTMFModes` API method and return the raw JSON envelope.
    pub async fn get_dtmf_modes_raw(&self, params: &GetDTMFModesParams) -> Result<Value> {
        self.call_raw("getDTMFModes", params).await
    }

    /// \- Retrieves Deposits made for a specific Reseller Client.
    ///
    /// Call the `getDeposits` API method and deserialize into [`GetDepositsResponse`].
    pub async fn get_deposits(&self, params: &GetDepositsParams) -> Result<GetDepositsResponse> {
        self.call("getDeposits", params).await
    }

    /// Call the `getDeposits` API method and return the raw JSON envelope.
    pub async fn get_deposits_raw(&self, params: &GetDepositsParams) -> Result<Value> {
        self.call_raw("getDeposits", params).await
    }

    /// \- Retrieves a list of Device Types if no additional parameter is
    /// provided.
    /// \- Retrieves a specific Device Type if a device type code is provided.
    ///
    /// Call the `getDeviceTypes` API method and deserialize into [`GetDeviceTypesResponse`].
    pub async fn get_device_types(
        &self,
        params: &GetDeviceTypesParams,
    ) -> Result<GetDeviceTypesResponse> {
        self.call("getDeviceTypes", params).await
    }

    /// Call the `getDeviceTypes` API method and return the raw JSON envelope.
    pub async fn get_device_types_raw(&self, params: &GetDeviceTypesParams) -> Result<Value> {
        self.call_raw("getDeviceTypes", params).await
    }

    /// \- Retrieves a list of "Email to Fax configurations" from your account if
    /// no additional parameter is provided.
    /// \- Retrieves a specific "Email to Fax configuration" from your account if
    /// a ID is provided.
    ///
    /// Call the `getEmailToFax` API method and deserialize into [`GetEmailToFAXResponse`].
    pub async fn get_email_to_fax(
        &self,
        params: &GetEmailToFAXParams,
    ) -> Result<GetEmailToFAXResponse> {
        self.call("getEmailToFax", params).await
    }

    /// Call the `getEmailToFax` API method and return the raw JSON envelope.
    pub async fn get_email_to_fax_raw(&self, params: &GetEmailToFAXParams) -> Result<Value> {
        self.call_raw("getEmailToFax", params).await
    }

    /// \- Retrieves a list of Fax Folders from your account.
    ///
    /// Call the `getFaxFolders` API method and deserialize into [`GetFAXFoldersResponse`].
    pub async fn get_fax_folders(
        &self,
        params: &GetFAXFoldersParams,
    ) -> Result<GetFAXFoldersResponse> {
        self.call("getFaxFolders", params).await
    }

    /// Call the `getFaxFolders` API method and return the raw JSON envelope.
    pub async fn get_fax_folders_raw(&self, params: &GetFAXFoldersParams) -> Result<Value> {
        self.call_raw("getFaxFolders", params).await
    }

    /// \- Retrieves a Base64 code of the Fax Message to create a PDF file.
    ///
    /// Call the `getFaxMessagePDF` API method and deserialize into [`GetFAXMessagePDFResponse`].
    pub async fn get_fax_message_pdf(
        &self,
        params: &GetFAXMessagePDFParams,
    ) -> Result<GetFAXMessagePDFResponse> {
        self.call("getFaxMessagePDF", params).await
    }

    /// Call the `getFaxMessagePDF` API method and return the raw JSON envelope.
    pub async fn get_fax_message_pdf_raw(&self, params: &GetFAXMessagePDFParams) -> Result<Value> {
        self.call_raw("getFaxMessagePDF", params).await
    }

    /// \- Retrieves a list of Fax Messages.
    /// \- Retrieves a specific Fax Message if a Fax Message ID is provided.
    ///
    /// Call the `getFaxMessages` API method and deserialize into [`GetFAXMessagesResponse`].
    pub async fn get_fax_messages(
        &self,
        params: &GetFAXMessagesParams,
    ) -> Result<GetFAXMessagesResponse> {
        self.call("getFaxMessages", params).await
    }

    /// Call the `getFaxMessages` API method and return the raw JSON envelope.
    pub async fn get_fax_messages_raw(&self, params: &GetFAXMessagesParams) -> Result<Value> {
        self.call_raw("getFaxMessages", params).await
    }

    /// \- Retrieves a list of Fax Numbers.
    ///
    /// Call the `getFaxNumbersInfo` API method and deserialize into [`GetFAXNumbersInfoResponse`].
    pub async fn get_fax_numbers_info(
        &self,
        params: &GetFAXNumbersInfoParams,
    ) -> Result<GetFAXNumbersInfoResponse> {
        self.call("getFaxNumbersInfo", params).await
    }

    /// Call the `getFaxNumbersInfo` API method and return the raw JSON envelope.
    pub async fn get_fax_numbers_info_raw(
        &self,
        params: &GetFAXNumbersInfoParams,
    ) -> Result<Value> {
        self.call_raw("getFaxNumbersInfo", params).await
    }

    /// \- Shows if a Fax Number can be ported into our network
    ///
    /// Call the `getFaxNumbersPortability` API method and deserialize into [`GetFAXNumbersPortabilityResponse`].
    pub async fn get_fax_numbers_portability(
        &self,
        params: &GetFAXNumbersPortabilityParams,
    ) -> Result<GetFAXNumbersPortabilityResponse> {
        self.call("getFaxNumbersPortability", params).await
    }

    /// Call the `getFaxNumbersPortability` API method and return the raw JSON envelope.
    pub async fn get_fax_numbers_portability_raw(
        &self,
        params: &GetFAXNumbersPortabilityParams,
    ) -> Result<Value> {
        self.call_raw("getFaxNumbersPortability", params).await
    }

    /// \- Retrieves a list of Canadian Fax Provinces if no additional parameter
    /// is provided.
    /// \- Retrieves a specific Canadian Fax Province if a province code is
    /// provided.
    ///
    /// Call the `getFaxProvinces` API method and deserialize into [`GetFAXProvincesResponse`].
    pub async fn get_fax_provinces(
        &self,
        params: &GetFAXProvincesParams,
    ) -> Result<GetFAXProvincesResponse> {
        self.call("getFaxProvinces", params).await
    }

    /// Call the `getFaxProvinces` API method and return the raw JSON envelope.
    pub async fn get_fax_provinces_raw(&self, params: &GetFAXProvincesParams) -> Result<Value> {
        self.call_raw("getFaxProvinces", params).await
    }

    /// \- Retrieves a list of Canadian Ratecenters by Province.
    ///
    /// Call the `getFaxRateCentersCAN` API method and deserialize into [`GetFAXRateCentersCANResponse`].
    pub async fn get_fax_rate_centers_can(
        &self,
        params: &GetFAXRateCentersCANParams,
    ) -> Result<GetFAXRateCentersCANResponse> {
        self.call("getFaxRateCentersCAN", params).await
    }

    /// Call the `getFaxRateCentersCAN` API method and return the raw JSON envelope.
    pub async fn get_fax_rate_centers_can_raw(
        &self,
        params: &GetFAXRateCentersCANParams,
    ) -> Result<Value> {
        self.call_raw("getFaxRateCentersCAN", params).await
    }

    /// \- Retrieves a list of USA Ratecenters by State.
    ///
    /// Call the `getFaxRateCentersUSA` API method and deserialize into [`GetFAXRateCentersUSAResponse`].
    pub async fn get_fax_rate_centers_usa(
        &self,
        params: &GetFAXRateCentersUSAParams,
    ) -> Result<GetFAXRateCentersUSAResponse> {
        self.call("getFaxRateCentersUSA", params).await
    }

    /// Call the `getFaxRateCentersUSA` API method and return the raw JSON envelope.
    pub async fn get_fax_rate_centers_usa_raw(
        &self,
        params: &GetFAXRateCentersUSAParams,
    ) -> Result<Value> {
        self.call_raw("getFaxRateCentersUSA", params).await
    }

    /// \- Retrieves a list of American Fax States if no additional parameter is
    /// provided.
    /// \- Retrieves a specific American Fax State if a state code is provided.
    ///
    /// Call the `getFaxStates` API method and deserialize into [`GetFAXStatesResponse`].
    pub async fn get_fax_states(
        &self,
        params: &GetFAXStatesParams,
    ) -> Result<GetFAXStatesResponse> {
        self.call("getFaxStates", params).await
    }

    /// Call the `getFaxStates` API method and return the raw JSON envelope.
    pub async fn get_fax_states_raw(&self, params: &GetFAXStatesParams) -> Result<Value> {
        self.call_raw("getFaxStates", params).await
    }

    /// \- Retrieves a list of Forwardings if no additional parameter is
    /// provided.
    /// \- Retrieves a specific Forwarding if a fwd code is provided.
    ///
    /// Call the `getForwardings` API method and deserialize into [`GetForwardingsResponse`].
    pub async fn get_forwardings(
        &self,
        params: &GetForwardingsParams,
    ) -> Result<GetForwardingsResponse> {
        self.call("getForwardings", params).await
    }

    /// Call the `getForwardings` API method and return the raw JSON envelope.
    pub async fn get_forwardings_raw(&self, params: &GetForwardingsParams) -> Result<Value> {
        self.call_raw("getForwardings", params).await
    }

    /// \- Shows the IP used by the client application requesting information
    /// from the API
    /// \* this is the only function not using the IP for authentication.
    /// \* the IP returned should be the one used in the API Configuration.
    ///
    /// Call the `getIP` API method and deserialize into [`GetIPResponse`].
    pub async fn get_ip(&self, params: &GetIPParams) -> Result<GetIPResponse> {
        self.call("getIP", params).await
    }

    /// Call the `getIP` API method and return the raw JSON envelope.
    pub async fn get_ip_raw(&self, params: &GetIPParams) -> Result<Value> {
        self.call_raw("getIP", params).await
    }

    /// \- Retrieves a list of IVRs if no additional parameter is provided.
    /// \- Retrieves a specific IVR if a IVR code is provided.
    ///
    /// Call the `getIVRs` API method and deserialize into [`GetIVRsResponse`].
    pub async fn get_ivrs(&self, params: &GetIVRsParams) -> Result<GetIVRsResponse> {
        self.call("getIVRs", params).await
    }

    /// Call the `getIVRs` API method and return the raw JSON envelope.
    pub async fn get_ivrs_raw(&self, params: &GetIVRsParams) -> Result<Value> {
        self.call_raw("getIVRs", params).await
    }

    /// \- Retrieves a list of Types for International DIDs if no additional
    /// parameter is provided.
    /// \- Retrieves a specific Types for International DIDs if a type code is
    /// provided.
    ///
    /// Call the `getInternationalTypes` API method and deserialize into [`GetInternationalTypesResponse`].
    pub async fn get_international_types(
        &self,
        params: &GetInternationalTypesParams,
    ) -> Result<GetInternationalTypesResponse> {
        self.call("getInternationalTypes", params).await
    }

    /// Call the `getInternationalTypes` API method and return the raw JSON envelope.
    pub async fn get_international_types_raw(
        &self,
        params: &GetInternationalTypesParams,
    ) -> Result<Value> {
        self.call_raw("getInternationalTypes", params).await
    }

    /// \- Retrieves a list of 'JoinWhenEmpty' Types if no additional parameter
    /// is provided.
    /// \- Retrieves a specific 'JoinWhenEmpty' Types if a type code is provided.
    ///
    /// Call the `getJoinWhenEmptyTypes` API method and deserialize into [`GetJoinWhenEmptyTypesResponse`].
    pub async fn get_join_when_empty_types(
        &self,
        params: &GetJoinWhenEmptyTypesParams,
    ) -> Result<GetJoinWhenEmptyTypesResponse> {
        self.call("getJoinWhenEmptyTypes", params).await
    }

    /// Call the `getJoinWhenEmptyTypes` API method and return the raw JSON envelope.
    pub async fn get_join_when_empty_types_raw(
        &self,
        params: &GetJoinWhenEmptyTypesParams,
    ) -> Result<Value> {
        self.call_raw("getJoinWhenEmptyTypes", params).await
    }

    /// \- Retrieve the details of an attached invoice.
    ///
    /// Call the `getLNPAttach` API method and deserialize into [`GetLNPAttachResponse`].
    pub async fn get_lnp_attach(
        &self,
        params: &GetLNPAttachParams,
    ) -> Result<GetLNPAttachResponse> {
        self.call("getLNPAttach", params).await
    }

    /// Call the `getLNPAttach` API method and return the raw JSON envelope.
    pub async fn get_lnp_attach_raw(&self, params: &GetLNPAttachParams) -> Result<Value> {
        self.call_raw("getLNPAttach", params).await
    }

    /// \- Retrieve the list of invoice (attached) files from a given portability
    /// process.
    ///
    /// Call the `getLNPAttachList` API method and deserialize into [`GetLNPAttachListResponse`].
    pub async fn get_lnp_attach_list(
        &self,
        params: &GetLNPAttachListParams,
    ) -> Result<GetLNPAttachListResponse> {
        self.call("getLNPAttachList", params).await
    }

    /// Call the `getLNPAttachList` API method and return the raw JSON envelope.
    pub async fn get_lnp_attach_list_raw(&self, params: &GetLNPAttachListParams) -> Result<Value> {
        self.call_raw("getLNPAttachList", params).await
    }

    /// \- Retrieve the details of a given portability process.
    ///
    /// Call the `getLNPDetails` API method and deserialize into [`GetLNPDetailsResponse`].
    pub async fn get_lnp_details(
        &self,
        params: &GetLNPDetailsParams,
    ) -> Result<GetLNPDetailsResponse> {
        self.call("getLNPDetails", params).await
    }

    /// Call the `getLNPDetails` API method and return the raw JSON envelope.
    pub async fn get_lnp_details_raw(&self, params: &GetLNPDetailsParams) -> Result<Value> {
        self.call_raw("getLNPDetails", params).await
    }

    /// \- Retrieve the full list of all your portability processes.
    ///
    /// Call the `getLNPList` API method and deserialize into [`GetLNPListResponse`].
    pub async fn get_lnp_list(&self, params: &GetLNPListParams) -> Result<GetLNPListResponse> {
        self.call("getLNPList", params).await
    }

    /// Call the `getLNPList` API method and return the raw JSON envelope.
    pub async fn get_lnp_list_raw(&self, params: &GetLNPListParams) -> Result<Value> {
        self.call_raw("getLNPList", params).await
    }

    /// \- Retrieve the list of possible status of a portability process.
    ///
    /// Call the `getLNPListStatus` API method and deserialize into [`GetLNPListStatusResponse`].
    pub async fn get_lnp_list_status(
        &self,
        params: &GetLNPListStatusParams,
    ) -> Result<GetLNPListStatusResponse> {
        self.call("getLNPListStatus", params).await
    }

    /// Call the `getLNPListStatus` API method and return the raw JSON envelope.
    pub async fn get_lnp_list_status_raw(&self, params: &GetLNPListStatusParams) -> Result<Value> {
        self.call_raw("getLNPListStatus", params).await
    }

    /// \- Retrieve the list of notes from the given portability process.
    ///
    /// Call the `getLNPNotes` API method and deserialize into [`GetLNPNotesResponse`].
    pub async fn get_lnp_notes(&self, params: &GetLNPNotesParams) -> Result<GetLNPNotesResponse> {
        self.call("getLNPNotes", params).await
    }

    /// Call the `getLNPNotes` API method and return the raw JSON envelope.
    pub async fn get_lnp_notes_raw(&self, params: &GetLNPNotesParams) -> Result<Value> {
        self.call_raw("getLNPNotes", params).await
    }

    /// \- Retrieve the current status of a given portability process.
    ///
    /// Call the `getLNPStatus` API method and deserialize into [`GetLNPStatusResponse`].
    pub async fn get_lnp_status(
        &self,
        params: &GetLNPStatusParams,
    ) -> Result<GetLNPStatusResponse> {
        self.call("getLNPStatus", params).await
    }

    /// Call the `getLNPStatus` API method and return the raw JSON envelope.
    pub async fn get_lnp_status_raw(&self, params: &GetLNPStatusParams) -> Result<Value> {
        self.call_raw("getLNPStatus", params).await
    }

    /// \- Retrieves a list of Languages if no additional parameter is provided.
    /// \- Retrieves a specific Language if a language code is provided.
    ///
    /// Call the `getLanguages` API method and deserialize into [`GetLanguagesResponse`].
    pub async fn get_languages(&self, params: &GetLanguagesParams) -> Result<GetLanguagesResponse> {
        self.call("getLanguages", params).await
    }

    /// Call the `getLanguages` API method and return the raw JSON envelope.
    pub async fn get_languages_raw(&self, params: &GetLanguagesParams) -> Result<Value> {
        self.call_raw("getLanguages", params).await
    }

    /// \- Retrieves a list of locale codes if no additional parameter is
    /// provided.
    /// \- Retrieves a specific locale code if a language code is provided.
    ///
    /// Call the `getLocales` API method and deserialize into [`GetLocalesResponse`].
    pub async fn get_locales(&self, params: &GetLocalesParams) -> Result<GetLocalesResponse> {
        self.call("getLocales", params).await
    }

    /// Call the `getLocales` API method and return the raw JSON envelope.
    pub async fn get_locales_raw(&self, params: &GetLocalesParams) -> Result<Value> {
        self.call_raw("getLocales", params).await
    }

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

    /// Call the `getLocations` API method and return the raw JSON envelope.
    pub async fn get_locations_raw(&self, params: &GetLocationsParams) -> Result<Value> {
        self.call_raw("getLocations", params).await
    }

    /// \- Retrieves a list of Lock Modes if no additional parameter is provided.
    /// \- Retrieves a specific Lock Mode if a lock code is provided.
    ///
    /// Call the `getLockInternational` API method and deserialize into [`GetLockInternationalResponse`].
    pub async fn get_lock_international(
        &self,
        params: &GetLockInternationalParams,
    ) -> Result<GetLockInternationalResponse> {
        self.call("getLockInternational", params).await
    }

    /// Call the `getLockInternational` API method and return the raw JSON envelope.
    pub async fn get_lock_international_raw(
        &self,
        params: &GetLockInternationalParams,
    ) -> Result<Value> {
        self.call_raw("getLockInternational", params).await
    }

    /// \- Retrieves a list of MMS messages by: date range, mms type, DID number,
    /// and contact.
    ///
    /// Call the `getMMS` API method and deserialize into [`GetMMSResponse`].
    ///
    /// A `timezone` zone is resolved to the numeric UTC offset the wire
    /// expects, at the query start date; a zone that cannot be resolved
    /// is [`Error::InvalidParams`](crate::Error::InvalidParams).
    pub async fn get_mms(&self, params: &GetMMSParams) -> Result<GetMMSResponse> {
        self.call("getMMS", &GetMMSParamsWire::try_from(params)?)
            .await
    }

    /// Call the `getMMS` API method and return the raw JSON envelope.
    ///
    /// A `timezone` zone is resolved to the numeric UTC offset the wire
    /// expects, at the query start date; a zone that cannot be resolved
    /// is [`Error::InvalidParams`](crate::Error::InvalidParams).
    pub async fn get_mms_raw(&self, params: &GetMMSParams) -> Result<Value> {
        self.call_raw("getMMS", &GetMMSParamsWire::try_from(params)?)
            .await
    }

    /// \- Retrieves media files from the message.
    ///
    /// Call the `getMediaMMS` API method and deserialize into [`GetMediaMMSResponse`].
    pub async fn get_media_mms(&self, params: &GetMediaMMSParams) -> Result<GetMediaMMSResponse> {
        self.call("getMediaMMS", params).await
    }

    /// Call the `getMediaMMS` API method and return the raw JSON envelope.
    pub async fn get_media_mms_raw(&self, params: &GetMediaMMSParams) -> Result<Value> {
        self.call_raw("getMediaMMS", params).await
    }

    /// \- Retrieves a list of Music on Hold Options if no additional parameter
    /// is provided.
    /// \- Retrieves a specific Music on Hold Option if a MOH code is provided.
    ///
    /// Call the `getMusicOnHold` API method and deserialize into [`GetMusicOnHoldResponse`].
    pub async fn get_music_on_hold(
        &self,
        params: &GetMusicOnHoldParams,
    ) -> Result<GetMusicOnHoldResponse> {
        self.call("getMusicOnHold", params).await
    }

    /// Call the `getMusicOnHold` API method and return the raw JSON envelope.
    pub async fn get_music_on_hold_raw(&self, params: &GetMusicOnHoldParams) -> Result<Value> {
        self.call_raw("getMusicOnHold", params).await
    }

    /// \- Retrieves a list of NAT Options if no additional parameter is
    /// provided.
    /// \- Retrieves a specific NAT Option if a NAT code is provided.
    ///
    /// Call the `getNAT` API method and deserialize into [`GetNATResponse`].
    pub async fn get_nat(&self, params: &GetNATParams) -> Result<GetNATResponse> {
        self.call("getNAT", params).await
    }

    /// Call the `getNAT` API method and return the raw JSON envelope.
    pub async fn get_nat_raw(&self, params: &GetNATParams) -> Result<Value> {
        self.call_raw("getNAT", params).await
    }

    /// \- Retrieves a list of Packages if no additional parameter is provided.-
    /// Retrieves a specific Package if a package code is provided.
    ///
    /// Call the `getPackages` API method and deserialize into [`GetPackagesResponse`].
    pub async fn get_packages(&self, params: &GetPackagesParams) -> Result<GetPackagesResponse> {
        self.call("getPackages", params).await
    }

    /// Call the `getPackages` API method and return the raw JSON envelope.
    pub async fn get_packages_raw(&self, params: &GetPackagesParams) -> Result<Value> {
        self.call_raw("getPackages", params).await
    }

    /// \- Retrieves a list of Phonebook entries if no additional parameter is
    /// provided.
    /// \- Retrieves a list of Phonebook entries if a name is provided.
    /// \- Retrieves a specific Phonebook entry if a Phonebook code is provided.
    /// \- Retrieves a list of Phonebook entries if a phonebook group name is
    /// provided.
    /// \- Retrieves a list of Phonebook entries if a phonebook group code is
    /// provided.
    ///
    /// Call the `getPhonebook` API method and deserialize into [`GetPhonebookResponse`].
    pub async fn get_phonebook(&self, params: &GetPhonebookParams) -> Result<GetPhonebookResponse> {
        self.call("getPhonebook", params).await
    }

    /// Call the `getPhonebook` API method and return the raw JSON envelope.
    pub async fn get_phonebook_raw(&self, params: &GetPhonebookParams) -> Result<Value> {
        self.call_raw("getPhonebook", params).await
    }

    /// \- Retrieves a list of Phonebook groups if no additional parameter is
    /// provided.
    /// \- Retrieves a list of Phonebook groups if a name is provided.
    /// \- Retrieves a specific Phonebook group if a group ID is provided.
    ///
    /// Call the `getPhonebookGroups` API method and deserialize into [`GetPhonebookGroupsResponse`].
    pub async fn get_phonebook_groups(
        &self,
        params: &GetPhonebookGroupsParams,
    ) -> Result<GetPhonebookGroupsResponse> {
        self.call("getPhonebookGroups", params).await
    }

    /// Call the `getPhonebookGroups` API method and return the raw JSON envelope.
    pub async fn get_phonebook_groups_raw(
        &self,
        params: &GetPhonebookGroupsParams,
    ) -> Result<Value> {
        self.call_raw("getPhonebookGroups", params).await
    }

    /// \- Retrieves a list of Play Instructions modes if no additional parameter
    /// is provided.
    /// \- Retrieves a specific Play Instructions mode if a play code is
    /// provided.
    ///
    /// Call the `getPlayInstructions` API method and deserialize into [`GetPlayInstructionsResponse`].
    pub async fn get_play_instructions(
        &self,
        params: &GetPlayInstructionsParams,
    ) -> Result<GetPlayInstructionsResponse> {
        self.call("getPlayInstructions", params).await
    }

    /// Call the `getPlayInstructions` API method and return the raw JSON envelope.
    pub async fn get_play_instructions_raw(
        &self,
        params: &GetPlayInstructionsParams,
    ) -> Result<Value> {
        self.call_raw("getPlayInstructions", params).await
    }

    /// \- Shows if a DID Number can be ported into our network.
    /// \- Display plans and rates available if the DID Number can be ported into
    /// our network.
    ///
    /// Call the `getPortability` API method and deserialize into [`GetPortabilityResponse`].
    pub async fn get_portability(
        &self,
        params: &GetPortabilityParams,
    ) -> Result<GetPortabilityResponse> {
        self.call("getPortability", params).await
    }

    /// Call the `getPortability` API method and return the raw JSON envelope.
    pub async fn get_portability_raw(&self, params: &GetPortabilityParams) -> Result<Value> {
        self.call_raw("getPortability", params).await
    }

    /// \- Retrieves a list of Protocols if no additional parameter is provided.
    /// \- Retrieves a specific Protocol if a protocol code is provided.
    ///
    /// Call the `getProtocols` API method and deserialize into [`GetProtocolsResponse`].
    pub async fn get_protocols(&self, params: &GetProtocolsParams) -> Result<GetProtocolsResponse> {
        self.call("getProtocols", params).await
    }

    /// Call the `getProtocols` API method and return the raw JSON envelope.
    pub async fn get_protocols_raw(&self, params: &GetProtocolsParams) -> Result<Value> {
        self.call_raw("getProtocols", params).await
    }

    /// \- Retrieves a list of Canadian Provinces.
    ///
    /// Call the `getProvinces` API method and deserialize into [`GetProvincesResponse`].
    pub async fn get_provinces(&self, params: &GetProvincesParams) -> Result<GetProvincesResponse> {
        self.call("getProvinces", params).await
    }

    /// Call the `getProvinces` API method and return the raw JSON envelope.
    pub async fn get_provinces_raw(&self, params: &GetProvincesParams) -> Result<Value> {
        self.call_raw("getProvinces", params).await
    }

    /// \- Retrieves a list of Queue entries if no additional parameter is
    /// provided.
    /// \- Retrieves a specific Queue entry if a Queue code is provided.
    ///
    /// Call the `getQueues` API method and deserialize into [`GetQueuesResponse`].
    pub async fn get_queues(&self, params: &GetQueuesParams) -> Result<GetQueuesResponse> {
        self.call("getQueues", params).await
    }

    /// Call the `getQueues` API method and return the raw JSON envelope.
    pub async fn get_queues_raw(&self, params: &GetQueuesParams) -> Result<Value> {
        self.call_raw("getQueues", params).await
    }

    /// \- Retrieves a list of Canadian Ratecenters by Province.
    ///
    /// Call the `getRateCentersCAN` API method and deserialize into [`GetRateCentersCANResponse`].
    pub async fn get_rate_centers_can(
        &self,
        params: &GetRateCentersCANParams,
    ) -> Result<GetRateCentersCANResponse> {
        self.call("getRateCentersCAN", params).await
    }

    /// Call the `getRateCentersCAN` API method and return the raw JSON envelope.
    pub async fn get_rate_centers_can_raw(
        &self,
        params: &GetRateCentersCANParams,
    ) -> Result<Value> {
        self.call_raw("getRateCentersCAN", params).await
    }

    /// \- Retrieves a list of USA Ratecenters by State.
    ///
    /// Call the `getRateCentersUSA` API method and deserialize into [`GetRateCentersUSAResponse`].
    pub async fn get_rate_centers_usa(
        &self,
        params: &GetRateCentersUSAParams,
    ) -> Result<GetRateCentersUSAResponse> {
        self.call("getRateCentersUSA", params).await
    }

    /// Call the `getRateCentersUSA` API method and return the raw JSON envelope.
    pub async fn get_rate_centers_usa_raw(
        &self,
        params: &GetRateCentersUSAParams,
    ) -> Result<Value> {
        self.call_raw("getRateCentersUSA", params).await
    }

    /// \- Retrieves the Rates for a specific Package and a Search term.
    ///
    /// Call the `getRates` API method and deserialize into [`GetRatesResponse`].
    pub async fn get_rates(&self, params: &GetRatesParams) -> Result<GetRatesResponse> {
        self.call("getRates", params).await
    }

    /// Call the `getRates` API method and return the raw JSON envelope.
    pub async fn get_rates_raw(&self, params: &GetRatesParams) -> Result<Value> {
        self.call_raw("getRates", params).await
    }

    /// \- Retrieves a specific Recording File data in Base64 format.
    ///
    /// Call the `getRecordingFile` API method and deserialize into [`GetRecordingFileResponse`].
    pub async fn get_recording_file(
        &self,
        params: &GetRecordingFileParams,
    ) -> Result<GetRecordingFileResponse> {
        self.call("getRecordingFile", params).await
    }

    /// Call the `getRecordingFile` API method and return the raw JSON envelope.
    pub async fn get_recording_file_raw(&self, params: &GetRecordingFileParams) -> Result<Value> {
        self.call_raw("getRecordingFile", params).await
    }

    /// \- Retrieves a list of Recordings if no additional parameter is provided.
    /// \- Retrieves a specific Recording if a Recording code is provided.
    ///
    /// Call the `getRecordings` API method and deserialize into [`GetRecordingsResponse`].
    pub async fn get_recordings(
        &self,
        params: &GetRecordingsParams,
    ) -> Result<GetRecordingsResponse> {
        self.call("getRecordings", params).await
    }

    /// Call the `getRecordings` API method and return the raw JSON envelope.
    pub async fn get_recordings_raw(&self, params: &GetRecordingsParams) -> Result<Value> {
        self.call_raw("getRecordings", params).await
    }

    /// \- Retrieves the Registration Status of all accounts if no account is
    /// provided.
    ///
    /// Call the `getRegistrationStatus` API method and deserialize into [`GetRegistrationStatusResponse`].
    pub async fn get_registration_status(
        &self,
        params: &GetRegistrationStatusParams,
    ) -> Result<GetRegistrationStatusResponse> {
        self.call("getRegistrationStatus", params).await
    }

    /// Call the `getRegistrationStatus` API method and return the raw JSON envelope.
    pub async fn get_registration_status_raw(
        &self,
        params: &GetRegistrationStatusParams,
    ) -> Result<Value> {
        self.call_raw("getRegistrationStatus", params).await
    }

    /// \- Retrieves a list of 'ReportEstimateHoldTime' Types if no additional
    /// parameter is provided.
    /// \- Retrieves a specific 'ReportEstimateHoldTime' Type if a type code is
    /// provided.
    ///
    /// Call the `getReportEstimatedHoldTime` API method and deserialize into [`GetReportEstimatedHoldTimeResponse`].
    pub async fn get_report_estimated_hold_time(
        &self,
        params: &GetReportEstimatedHoldTimeParams,
    ) -> Result<GetReportEstimatedHoldTimeResponse> {
        self.call("getReportEstimatedHoldTime", params).await
    }

    /// Call the `getReportEstimatedHoldTime` API method and return the raw JSON envelope.
    pub async fn get_report_estimated_hold_time_raw(
        &self,
        params: &GetReportEstimatedHoldTimeParams,
    ) -> Result<Value> {
        self.call_raw("getReportEstimatedHoldTime", params).await
    }

    /// \- Retrieves Balance and Calls Statistics for a specific Reseller Client
    /// for the last 30 days and current day.
    ///
    /// Call the `getResellerBalance` API method and deserialize into [`GetResellerBalanceResponse`].
    pub async fn get_reseller_balance(
        &self,
        params: &GetResellerBalanceParams,
    ) -> Result<GetResellerBalanceResponse> {
        self.call("getResellerBalance", params).await
    }

    /// Call the `getResellerBalance` API method and return the raw JSON envelope.
    pub async fn get_reseller_balance_raw(
        &self,
        params: &GetResellerBalanceParams,
    ) -> Result<Value> {
        self.call_raw("getResellerBalance", params).await
    }

    /// \- Retrieves the Call Detail Records for a specific Reseller Client.
    ///
    /// Call the `getResellerCDR` API method and deserialize into [`GetResellerCDRResponse`].
    ///
    /// A `timezone` zone is resolved to the numeric UTC offset the wire
    /// expects, at the query start date; a zone that cannot be resolved
    /// is [`Error::InvalidParams`](crate::Error::InvalidParams).
    pub async fn get_reseller_cdr(
        &self,
        params: &GetResellerCDRParams,
    ) -> Result<GetResellerCDRResponse> {
        self.call(
            "getResellerCDR",
            &GetResellerCDRParamsWire::try_from(params)?,
        )
        .await
    }

    /// Call the `getResellerCDR` API method and return the raw JSON envelope.
    ///
    /// A `timezone` zone is resolved to the numeric UTC offset the wire
    /// expects, at the query start date; a zone that cannot be resolved
    /// is [`Error::InvalidParams`](crate::Error::InvalidParams).
    pub async fn get_reseller_cdr_raw(&self, params: &GetResellerCDRParams) -> Result<Value> {
        self.call_raw(
            "getResellerCDR",
            &GetResellerCDRParamsWire::try_from(params)?,
        )
        .await
    }

    /// \- Retrieves a list of MMS messages for a specific Reseller Client. by:
    /// date range, mms type, DID number, and contact
    ///
    /// Call the `getResellerMMS` API method and deserialize into [`GetResellerMMSResponse`].
    ///
    /// A `timezone` zone is resolved to the numeric UTC offset the wire
    /// expects, at the query start date; a zone that cannot be resolved
    /// is [`Error::InvalidParams`](crate::Error::InvalidParams).
    pub async fn get_reseller_mms(
        &self,
        params: &GetResellerMMSParams,
    ) -> Result<GetResellerMMSResponse> {
        self.call(
            "getResellerMMS",
            &GetResellerMMSParamsWire::try_from(params)?,
        )
        .await
    }

    /// Call the `getResellerMMS` API method and return the raw JSON envelope.
    ///
    /// A `timezone` zone is resolved to the numeric UTC offset the wire
    /// expects, at the query start date; a zone that cannot be resolved
    /// is [`Error::InvalidParams`](crate::Error::InvalidParams).
    pub async fn get_reseller_mms_raw(&self, params: &GetResellerMMSParams) -> Result<Value> {
        self.call_raw(
            "getResellerMMS",
            &GetResellerMMSParamsWire::try_from(params)?,
        )
        .await
    }

    /// \- Retrieves a list of SMS messages for a specific Reseller Client. by:
    /// date range, sms type, DID number, and contact
    ///
    /// Call the `getResellerSMS` API method and deserialize into [`GetResellerSMSResponse`].
    ///
    /// A `timezone` zone is resolved to the numeric UTC offset the wire
    /// expects, at the query start date; a zone that cannot be resolved
    /// is [`Error::InvalidParams`](crate::Error::InvalidParams).
    pub async fn get_reseller_sms(
        &self,
        params: &GetResellerSMSParams,
    ) -> Result<GetResellerSMSResponse> {
        self.call(
            "getResellerSMS",
            &GetResellerSMSParamsWire::try_from(params)?,
        )
        .await
    }

    /// Call the `getResellerSMS` API method and return the raw JSON envelope.
    ///
    /// A `timezone` zone is resolved to the numeric UTC offset the wire
    /// expects, at the query start date; a zone that cannot be resolved
    /// is [`Error::InvalidParams`](crate::Error::InvalidParams).
    pub async fn get_reseller_sms_raw(&self, params: &GetResellerSMSParams) -> Result<Value> {
        self.call_raw(
            "getResellerSMS",
            &GetResellerSMSParamsWire::try_from(params)?,
        )
        .await
    }

    /// \- Retrieves a list of Ring Groups if no additional parameter is
    /// provided.
    /// \- Retrieves a specific Ring Group if a ring group code is provided.
    ///
    /// Call the `getRingGroups` API method and deserialize into [`GetRingGroupsResponse`].
    pub async fn get_ring_groups(
        &self,
        params: &GetRingGroupsParams,
    ) -> Result<GetRingGroupsResponse> {
        self.call("getRingGroups", params).await
    }

    /// Call the `getRingGroups` API method and return the raw JSON envelope.
    pub async fn get_ring_groups_raw(&self, params: &GetRingGroupsParams) -> Result<Value> {
        self.call_raw("getRingGroups", params).await
    }

    /// \- Retrieves a list of Ring Strategies if no additional parameter is
    /// provided.
    /// \- Retrieves a specific Ring Strategy if a ring strategy code is
    /// provided.
    ///
    /// Call the `getRingStrategies` API method and deserialize into [`GetRingStrategiesResponse`].
    pub async fn get_ring_strategies(
        &self,
        params: &GetRingStrategiesParams,
    ) -> Result<GetRingStrategiesResponse> {
        self.call("getRingStrategies", params).await
    }

    /// Call the `getRingStrategies` API method and return the raw JSON envelope.
    pub async fn get_ring_strategies_raw(&self, params: &GetRingStrategiesParams) -> Result<Value> {
        self.call_raw("getRingStrategies", params).await
    }

    /// \- Retrieves a list of Route Options if no additional parameter is
    /// provided.
    /// \- Retrieves a specific Route Option if a route code is provided.
    ///
    /// Call the `getRoutes` API method and deserialize into [`GetRoutesResponse`].
    pub async fn get_routes(&self, params: &GetRoutesParams) -> Result<GetRoutesResponse> {
        self.call("getRoutes", params).await
    }

    /// Call the `getRoutes` API method and return the raw JSON envelope.
    pub async fn get_routes_raw(&self, params: &GetRoutesParams) -> Result<Value> {
        self.call_raw("getRoutes", params).await
    }

    /// \- Retrieves a list of SIP URIs if no additional parameter is provided.
    /// \- Retrieves a specific SIP URI if a SIP URI code is provided.
    ///
    /// Call the `getSIPURIs` API method and deserialize into [`GetSIPURIsResponse`].
    pub async fn get_sip_uris(&self, params: &GetSIPURIsParams) -> Result<GetSIPURIsResponse> {
        self.call("getSIPURIs", params).await
    }

    /// Call the `getSIPURIs` API method and return the raw JSON envelope.
    pub async fn get_sip_uris_raw(&self, params: &GetSIPURIsParams) -> Result<Value> {
        self.call_raw("getSIPURIs", params).await
    }

    /// \- Retrieves a list of SMS messages by: date range, sms type, DID number,
    /// and contact.
    ///
    /// Call the `getSMS` API method and deserialize into [`GetSMSResponse`].
    ///
    /// A `timezone` zone is resolved to the numeric UTC offset the wire
    /// expects, at the query start date; a zone that cannot be resolved
    /// is [`Error::InvalidParams`](crate::Error::InvalidParams).
    pub async fn get_sms(&self, params: &GetSMSParams) -> Result<GetSMSResponse> {
        self.call("getSMS", &GetSMSParamsWire::try_from(params)?)
            .await
    }

    /// Call the `getSMS` API method and return the raw JSON envelope.
    ///
    /// A `timezone` zone is resolved to the numeric UTC offset the wire
    /// expects, at the query start date; a zone that cannot be resolved
    /// is [`Error::InvalidParams`](crate::Error::InvalidParams).
    pub async fn get_sms_raw(&self, params: &GetSMSParams) -> Result<Value> {
        self.call_raw("getSMS", &GetSMSParamsWire::try_from(params)?)
            .await
    }

    /// \- Retrieves a list of Servers with their info if no additional parameter
    /// is provided.
    /// \- Retrieves a specific Server with its info if a Server POP is provided.
    ///
    /// Call the `getServersInfo` API method and deserialize into [`GetServersInfoResponse`].
    pub async fn get_servers_info(
        &self,
        params: &GetServersInfoParams,
    ) -> Result<GetServersInfoResponse> {
        self.call("getServersInfo", params).await
    }

    /// Call the `getServersInfo` API method and return the raw JSON envelope.
    pub async fn get_servers_info_raw(&self, params: &GetServersInfoParams) -> Result<Value> {
        self.call_raw("getServersInfo", params).await
    }

    /// \- Retrieves a list of USA States.
    ///
    /// Call the `getStates` API method and deserialize into [`GetStatesResponse`].
    pub async fn get_states(&self, params: &GetStatesParams) -> Result<GetStatesResponse> {
        self.call("getStates", params).await
    }

    /// Call the `getStates` API method and return the raw JSON envelope.
    pub async fn get_states_raw(&self, params: &GetStatesParams) -> Result<Value> {
        self.call_raw("getStates", params).await
    }

    /// \- Retrieves a list of Static Members from a queue if no additional
    /// parameter is provided.
    /// \- Retrieves a specific Static Member from a queue if Queue ID and Member
    /// ID are provided
    ///
    /// Call the `getStaticMembers` API method and deserialize into [`GetStaticMembersResponse`].
    pub async fn get_static_members(
        &self,
        params: &GetStaticMembersParams,
    ) -> Result<GetStaticMembersResponse> {
        self.call("getStaticMembers", params).await
    }

    /// Call the `getStaticMembers` API method and return the raw JSON envelope.
    pub async fn get_static_members_raw(&self, params: &GetStaticMembersParams) -> Result<Value> {
        self.call_raw("getStaticMembers", params).await
    }

    /// \- Retrieves all Sub Accounts if no additional parameter is provided.
    /// \- Retrieves Reseller Client Accounts if Reseller Client ID is provided.
    /// \- Retrieves a specific Sub Account if a Sub Account is provided.
    ///
    /// Call the `getSubAccounts` API method and deserialize into [`GetSubAccountsResponse`].
    pub async fn get_sub_accounts(
        &self,
        params: &GetSubAccountsParams,
    ) -> Result<GetSubAccountsResponse> {
        self.call("getSubAccounts", params).await
    }

    /// Call the `getSubAccounts` API method and return the raw JSON envelope.
    pub async fn get_sub_accounts_raw(&self, params: &GetSubAccountsParams) -> Result<Value> {
        self.call_raw("getSubAccounts", params).await
    }

    /// \- Retrieves the Rates for a specific Route (Premium, Value) and a Search
    /// term.
    ///
    /// Call the `getTerminationRates` API method and deserialize into [`GetTerminationRatesResponse`].
    pub async fn get_termination_rates(
        &self,
        params: &GetTerminationRatesParams,
    ) -> Result<GetTerminationRatesResponse> {
        self.call("getTerminationRates", params).await
    }

    /// Call the `getTerminationRates` API method and return the raw JSON envelope.
    pub async fn get_termination_rates_raw(
        &self,
        params: &GetTerminationRatesParams,
    ) -> Result<Value> {
        self.call_raw("getTerminationRates", params).await
    }

    /// \- Retrieves a list of Time Conditions if no additional parameter is
    /// provided.
    /// \- Retrieves a specific Time Condition if a time condition code is
    /// provided.
    ///
    /// Call the `getTimeConditions` API method and deserialize into [`GetTimeConditionsResponse`].
    pub async fn get_time_conditions(
        &self,
        params: &GetTimeConditionsParams,
    ) -> Result<GetTimeConditionsResponse> {
        self.call("getTimeConditions", params).await
    }

    /// Call the `getTimeConditions` API method and return the raw JSON envelope.
    pub async fn get_time_conditions_raw(&self, params: &GetTimeConditionsParams) -> Result<Value> {
        self.call_raw("getTimeConditions", params).await
    }

    /// \- Retrieves a list of Timezones if no additional parameter is provided.
    /// \- Retrieves a specific Timezone if a timezone code is provided.
    ///
    /// Call the `getTimezones` API method and deserialize into [`GetTimezonesResponse`].
    pub async fn get_timezones(&self, params: &GetTimezonesParams) -> Result<GetTimezonesResponse> {
        self.call("getTimezones", params).await
    }

    /// Call the `getTimezones` API method and return the raw JSON envelope.
    pub async fn get_timezones_raw(&self, params: &GetTimezonesParams) -> Result<Value> {
        self.call_raw("getTimezones", params).await
    }

    /// \- Retrieves the Transaction History records between two dates.
    ///
    /// Call the `getTransactionHistory` API method and deserialize into [`GetTransactionHistoryResponse`].
    pub async fn get_transaction_history(
        &self,
        params: &GetTransactionHistoryParams,
    ) -> Result<GetTransactionHistoryResponse> {
        self.call("getTransactionHistory", params).await
    }

    /// Call the `getTransactionHistory` API method and return the raw JSON envelope.
    pub async fn get_transaction_history_raw(
        &self,
        params: &GetTransactionHistoryParams,
    ) -> Result<Value> {
        self.call_raw("getTransactionHistory", params).await
    }

    /// \- Retrieves a list of vpri.
    ///
    /// Call the `getVPRIs` API method and deserialize into [`GetVPRIsResponse`].
    pub async fn get_vpris(&self, params: &GetVPRIsParams) -> Result<GetVPRIsResponse> {
        self.call("getVPRIs", params).await
    }

    /// Call the `getVPRIs` API method and return the raw JSON envelope.
    pub async fn get_vpris_raw(&self, params: &GetVPRIsParams) -> Result<Value> {
        self.call_raw("getVPRIs", params).await
    }

    /// \- Retrieves a list of Email Attachment Format Options if no additional
    /// parameter is provided.
    /// \- Retrieves a specific Email Attachment Format Option if a format value
    /// is provided.
    ///
    /// Call the `getVoicemailAttachmentFormats` API method and deserialize into [`GetVoicemailAttachmentFormatsResponse`].
    pub async fn get_voicemail_attachment_formats(
        &self,
        params: &GetVoicemailAttachmentFormatsParams,
    ) -> Result<GetVoicemailAttachmentFormatsResponse> {
        self.call("getVoicemailAttachmentFormats", params).await
    }

    /// Call the `getVoicemailAttachmentFormats` API method and return the raw JSON envelope.
    pub async fn get_voicemail_attachment_formats_raw(
        &self,
        params: &GetVoicemailAttachmentFormatsParams,
    ) -> Result<Value> {
        self.call_raw("getVoicemailAttachmentFormats", params).await
    }

    /// \- Retrieves a list of default Voicemail Folders if no additional
    /// parameter is provided.
    /// \- Retrieves a list of Voicemail Folders within a mailbox if mailbox
    /// parameter is provided.
    /// \- Retrieves a specific Folder if a folder name is provided.
    ///
    /// Call the `getVoicemailFolders` API method and deserialize into [`GetVoicemailFoldersResponse`].
    pub async fn get_voicemail_folders(
        &self,
        params: &GetVoicemailFoldersParams,
    ) -> Result<GetVoicemailFoldersResponse> {
        self.call("getVoicemailFolders", params).await
    }

    /// Call the `getVoicemailFolders` API method and return the raw JSON envelope.
    pub async fn get_voicemail_folders_raw(
        &self,
        params: &GetVoicemailFoldersParams,
    ) -> Result<Value> {
        self.call_raw("getVoicemailFolders", params).await
    }

    /// \- Retrieves a specific Voicemail Message File in Base64 format.
    ///
    /// Call the `getVoicemailMessageFile` API method and deserialize into [`GetVoicemailMessageFileResponse`].
    pub async fn get_voicemail_message_file(
        &self,
        params: &GetVoicemailMessageFileParams,
    ) -> Result<GetVoicemailMessageFileResponse> {
        self.call("getVoicemailMessageFile", params).await
    }

    /// Call the `getVoicemailMessageFile` API method and return the raw JSON envelope.
    pub async fn get_voicemail_message_file_raw(
        &self,
        params: &GetVoicemailMessageFileParams,
    ) -> Result<Value> {
        self.call_raw("getVoicemailMessageFile", params).await
    }

    /// \- Retrieves a list of Voicemail Messages if mailbox parameter is
    /// provided.
    /// \- Retrieves a list of Voicemail Messages in a Folder if a folder is
    /// provided.
    /// \- Retrieves a list of Voicemail Messages in a date range if a from and
    /// to are provided.
    ///
    /// Call the `getVoicemailMessages` API method and deserialize into [`GetVoicemailMessagesResponse`].
    pub async fn get_voicemail_messages(
        &self,
        params: &GetVoicemailMessagesParams,
    ) -> Result<GetVoicemailMessagesResponse> {
        self.call("getVoicemailMessages", params).await
    }

    /// Call the `getVoicemailMessages` API method and return the raw JSON envelope.
    pub async fn get_voicemail_messages_raw(
        &self,
        params: &GetVoicemailMessagesParams,
    ) -> Result<Value> {
        self.call_raw("getVoicemailMessages", params).await
    }

    /// \- Retrieves a list of Voicemail Setup Options if no additional parameter
    /// is provided.
    /// \- Retrieves a specific Voicemail Setup Option if a voicemail setup code
    /// is provided.
    ///
    /// Call the `getVoicemailSetups` API method and deserialize into [`GetVoicemailSetupsResponse`].
    pub async fn get_voicemail_setups(
        &self,
        params: &GetVoicemailSetupsParams,
    ) -> Result<GetVoicemailSetupsResponse> {
        self.call("getVoicemailSetups", params).await
    }

    /// Call the `getVoicemailSetups` API method and return the raw JSON envelope.
    pub async fn get_voicemail_setups_raw(
        &self,
        params: &GetVoicemailSetupsParams,
    ) -> Result<Value> {
        self.call_raw("getVoicemailSetups", params).await
    }

    /// \- Retrieves all Voicemail Transcriptions if no additional parameter is
    /// provided.
    ///
    /// Call the `getVoicemailTranscriptions` API method and deserialize into [`GetVoicemailTranscriptionsResponse`].
    pub async fn get_voicemail_transcriptions(
        &self,
        params: &GetVoicemailTranscriptionsParams,
    ) -> Result<GetVoicemailTranscriptionsResponse> {
        self.call("getVoicemailTranscriptions", params).await
    }

    /// Call the `getVoicemailTranscriptions` API method and return the raw JSON envelope.
    pub async fn get_voicemail_transcriptions_raw(
        &self,
        params: &GetVoicemailTranscriptionsParams,
    ) -> Result<Value> {
        self.call_raw("getVoicemailTranscriptions", params).await
    }

    /// \- Retrieves a list of Voicemails if no additional parameter is provided.
    /// \- Retrieves a specific Voicemail if a voicemail code is provided.
    ///
    /// Call the `getVoicemails` API method and deserialize into [`GetVoicemailsResponse`].
    pub async fn get_voicemails(
        &self,
        params: &GetVoicemailsParams,
    ) -> Result<GetVoicemailsResponse> {
        self.call("getVoicemails", params).await
    }

    /// Call the `getVoicemails` API method and return the raw JSON envelope.
    pub async fn get_voicemails_raw(&self, params: &GetVoicemailsParams) -> Result<Value> {
        self.call_raw("getVoicemails", params).await
    }

    /// \- Send a Fax Message attached as a PDF file to an email destination.
    ///
    /// Call the `mailFaxMessagePDF` API method and deserialize into [`MailFAXMessagePDFResponse`].
    pub async fn mail_fax_message_pdf(
        &self,
        params: &MailFAXMessagePDFParams,
    ) -> Result<MailFAXMessagePDFResponse> {
        self.call("mailFaxMessagePDF", params).await
    }

    /// Call the `mailFaxMessagePDF` API method and return the raw JSON envelope.
    pub async fn mail_fax_message_pdf_raw(
        &self,
        params: &MailFAXMessagePDFParams,
    ) -> Result<Value> {
        self.call_raw("mailFaxMessagePDF", params).await
    }

    /// \- Mark a Voicemail Message as Listened or Unlistened.
    /// \- If value is 'yes', the voicemail message will be marked as listened
    /// and will be moved to the Old Folder.
    /// \- If value is 'no', the voicemail message will be marked as not-listened
    /// and will be moved to the INBOX Folder.
    ///
    /// Call the `markListenedVoicemailMessage` API method and deserialize into [`MarkListenedVoicemailMessageResponse`].
    pub async fn mark_listened_voicemail_message(
        &self,
        params: &MarkListenedVoicemailMessageParams,
    ) -> Result<MarkListenedVoicemailMessageResponse> {
        self.call("markListenedVoicemailMessage", params).await
    }

    /// Call the `markListenedVoicemailMessage` API method and return the raw JSON envelope.
    pub async fn mark_listened_voicemail_message_raw(
        &self,
        params: &MarkListenedVoicemailMessageParams,
    ) -> Result<Value> {
        self.call_raw("markListenedVoicemailMessage", params).await
    }

    /// \- Mark Voicemail Message as Urgent or not Urgent.
    /// \- If value is 'yes', the voicemail message will be marked as urgent and
    /// will be moved to the Urgent Folder.
    /// \- If value is 'no', the voicemail message will be unmarked as urgent and
    /// will be moved to the INBOX Folder.
    ///
    /// Call the `markUrgentVoicemailMessage` API method and deserialize into [`MarkUrgentVoicemailMessageResponse`].
    pub async fn mark_urgent_voicemail_message(
        &self,
        params: &MarkUrgentVoicemailMessageParams,
    ) -> Result<MarkUrgentVoicemailMessageResponse> {
        self.call("markUrgentVoicemailMessage", params).await
    }

    /// Call the `markUrgentVoicemailMessage` API method and return the raw JSON envelope.
    pub async fn mark_urgent_voicemail_message_raw(
        &self,
        params: &MarkUrgentVoicemailMessageParams,
    ) -> Result<Value> {
        self.call_raw("markUrgentVoicemailMessage", params).await
    }

    /// \- Moves a Fax Message to a different folder.
    ///
    /// Call the `moveFaxMessage` API method and deserialize into [`MoveFAXMessageResponse`].
    pub async fn move_fax_message(
        &self,
        params: &MoveFAXMessageParams,
    ) -> Result<MoveFAXMessageResponse> {
        self.call("moveFaxMessage", params).await
    }

    /// Call the `moveFaxMessage` API method and return the raw JSON envelope.
    pub async fn move_fax_message_raw(&self, params: &MoveFAXMessageParams) -> Result<Value> {
        self.call_raw("moveFaxMessage", params).await
    }

    /// \- Move Voicemail Message to a Destination Folder.
    ///
    /// Call the `moveFolderVoicemailMessage` API method and deserialize into [`MoveFolderVoicemailMessageResponse`].
    pub async fn move_folder_voicemail_message(
        &self,
        params: &MoveFolderVoicemailMessageParams,
    ) -> Result<MoveFolderVoicemailMessageResponse> {
        self.call("moveFolderVoicemailMessage", params).await
    }

    /// Call the `moveFolderVoicemailMessage` API method and return the raw JSON envelope.
    pub async fn move_folder_voicemail_message_raw(
        &self,
        params: &MoveFolderVoicemailMessageParams,
    ) -> Result<Value> {
        self.call_raw("moveFolderVoicemailMessage", params).await
    }

    /// \- Orders and Adds a new DID Number to the Account.
    ///
    /// Call the `orderDID` API method and deserialize into [`OrderDIDResponse`].
    pub async fn order_did(&self, params: &OrderDIDParams) -> Result<OrderDIDResponse> {
        self.call("orderDID", params).await
    }

    /// Call the `orderDID` API method and return the raw JSON envelope.
    pub async fn order_did_raw(&self, params: &OrderDIDParams) -> Result<Value> {
        self.call_raw("orderDID", params).await
    }

    /// \- Orders and Adds new International Geographic DID Numbers to the
    /// Account.
    ///
    /// Call the `orderDIDInternationalGeographic` API method and deserialize into [`OrderDIDInternationalGeographicResponse`].
    pub async fn order_did_international_geographic(
        &self,
        params: &OrderDIDInternationalGeographicParams,
    ) -> Result<OrderDIDInternationalGeographicResponse> {
        self.call("orderDIDInternationalGeographic", params).await
    }

    /// Call the `orderDIDInternationalGeographic` API method and return the raw JSON envelope.
    pub async fn order_did_international_geographic_raw(
        &self,
        params: &OrderDIDInternationalGeographicParams,
    ) -> Result<Value> {
        self.call_raw("orderDIDInternationalGeographic", params)
            .await
    }

    /// \- Orders and Adds new International National DID Numbers to the Account.
    ///
    /// Call the `orderDIDInternationalNational` API method and deserialize into [`OrderDIDInternationalNationalResponse`].
    pub async fn order_did_international_national(
        &self,
        params: &OrderDIDInternationalNationalParams,
    ) -> Result<OrderDIDInternationalNationalResponse> {
        self.call("orderDIDInternationalNational", params).await
    }

    /// Call the `orderDIDInternationalNational` API method and return the raw JSON envelope.
    pub async fn order_did_international_national_raw(
        &self,
        params: &OrderDIDInternationalNationalParams,
    ) -> Result<Value> {
        self.call_raw("orderDIDInternationalNational", params).await
    }

    /// \- Orders and Adds new International TollFree DID Numbers to the Account.
    ///
    /// Call the `orderDIDInternationalTollFree` API method and deserialize into [`OrderDIDInternationalTollFreeResponse`].
    pub async fn order_did_international_toll_free(
        &self,
        params: &OrderDIDInternationalTollFreeParams,
    ) -> Result<OrderDIDInternationalTollFreeResponse> {
        self.call("orderDIDInternationalTollFree", params).await
    }

    /// Call the `orderDIDInternationalTollFree` API method and return the raw JSON envelope.
    pub async fn order_did_international_toll_free_raw(
        &self,
        params: &OrderDIDInternationalTollFreeParams,
    ) -> Result<Value> {
        self.call_raw("orderDIDInternationalTollFree", params).await
    }

    /// \- Orders and Adds a new Virtual DID Number to the Account.
    ///
    /// Call the `orderDIDVirtual` API method and deserialize into [`OrderDIDVirtualResponse`].
    pub async fn order_did_virtual(
        &self,
        params: &OrderDIDVirtualParams,
    ) -> Result<OrderDIDVirtualResponse> {
        self.call("orderDIDVirtual", params).await
    }

    /// Call the `orderDIDVirtual` API method and return the raw JSON envelope.
    pub async fn order_did_virtual_raw(&self, params: &OrderDIDVirtualParams) -> Result<Value> {
        self.call_raw("orderDIDVirtual", params).await
    }

    /// \- Orders and Adds a new Fax Number to the Account.
    ///
    /// Call the `orderFaxNumber` API method and deserialize into [`OrderFAXNumberResponse`].
    pub async fn order_fax_number(
        &self,
        params: &OrderFAXNumberParams,
    ) -> Result<OrderFAXNumberResponse> {
        self.call("orderFaxNumber", params).await
    }

    /// Call the `orderFaxNumber` API method and return the raw JSON envelope.
    pub async fn order_fax_number_raw(&self, params: &OrderFAXNumberParams) -> Result<Value> {
        self.call_raw("orderFaxNumber", params).await
    }

    /// \- Orders and Adds a new Toll Free Number to the Account.
    ///
    /// Call the `orderTollFree` API method and deserialize into [`OrderTollFreeResponse`].
    pub async fn order_toll_free(
        &self,
        params: &OrderTollFreeParams,
    ) -> Result<OrderTollFreeResponse> {
        self.call("orderTollFree", params).await
    }

    /// Call the `orderTollFree` API method and return the raw JSON envelope.
    pub async fn order_toll_free_raw(&self, params: &OrderTollFreeParams) -> Result<Value> {
        self.call_raw("orderTollFree", params).await
    }

    /// \- Orders and Adds a new Vanity Toll Free Number to the Account.
    ///
    /// Call the `orderVanity` API method and deserialize into [`OrderVanityResponse`].
    pub async fn order_vanity(&self, params: &OrderVanityParams) -> Result<OrderVanityResponse> {
        self.call("orderVanity", params).await
    }

    /// Call the `orderVanity` API method and return the raw JSON envelope.
    pub async fn order_vanity_raw(&self, params: &OrderVanityParams) -> Result<Value> {
        self.call_raw("orderVanity", params).await
    }

    /// \- Removes a DID from a VPRI
    ///
    /// Call the `removeDIDvPRI` API method and deserialize into [`RemoveDIDvPRIResponse`].
    pub async fn remove_did_vpri(
        &self,
        params: &RemoveDIDvPRIParams,
    ) -> Result<RemoveDIDvPRIResponse> {
        self.call("removeDIDvPRI", params).await
    }

    /// Call the `removeDIDvPRI` API method and return the raw JSON envelope.
    pub async fn remove_did_vpri_raw(&self, params: &RemoveDIDvPRIParams) -> Result<Value> {
        self.call_raw("removeDIDvPRI", params).await
    }

    /// \- Searches for Canadian DIDs by Province using a Search Criteria.
    ///
    /// Call the `searchDIDsCAN` API method and deserialize into [`SearchDIDsCANResponse`].
    pub async fn search_dids_can(
        &self,
        params: &SearchDIDsCANParams,
    ) -> Result<SearchDIDsCANResponse> {
        self.call("searchDIDsCAN", params).await
    }

    /// Call the `searchDIDsCAN` API method and return the raw JSON envelope.
    pub async fn search_dids_can_raw(&self, params: &SearchDIDsCANParams) -> Result<Value> {
        self.call_raw("searchDIDsCAN", params).await
    }

    /// \- Searches for USA DIDs by State using a Search Criteria.
    ///
    /// Call the `searchDIDsUSA` API method and deserialize into [`SearchDIDsUSAResponse`].
    pub async fn search_dids_usa(
        &self,
        params: &SearchDIDsUSAParams,
    ) -> Result<SearchDIDsUSAResponse> {
        self.call("searchDIDsUSA", params).await
    }

    /// Call the `searchDIDsUSA` API method and return the raw JSON envelope.
    pub async fn search_dids_usa_raw(&self, params: &SearchDIDsUSAParams) -> Result<Value> {
        self.call_raw("searchDIDsUSA", params).await
    }

    /// \- Retrieves a list of Canadian Ratecenters searched by Area Code.
    ///
    /// Call the `searchFaxAreaCodeCAN` API method and deserialize into [`SearchFAXAreaCodeCANResponse`].
    pub async fn search_fax_area_code_can(
        &self,
        params: &SearchFAXAreaCodeCANParams,
    ) -> Result<SearchFAXAreaCodeCANResponse> {
        self.call("searchFaxAreaCodeCAN", params).await
    }

    /// Call the `searchFaxAreaCodeCAN` API method and return the raw JSON envelope.
    pub async fn search_fax_area_code_can_raw(
        &self,
        params: &SearchFAXAreaCodeCANParams,
    ) -> Result<Value> {
        self.call_raw("searchFaxAreaCodeCAN", params).await
    }

    /// \- Retrieves a list of USA Ratecenters searched by Area Code.
    ///
    /// Call the `searchFaxAreaCodeUSA` API method and deserialize into [`SearchFAXAreaCodeUSAResponse`].
    pub async fn search_fax_area_code_usa(
        &self,
        params: &SearchFAXAreaCodeUSAParams,
    ) -> Result<SearchFAXAreaCodeUSAResponse> {
        self.call("searchFaxAreaCodeUSA", params).await
    }

    /// Call the `searchFaxAreaCodeUSA` API method and return the raw JSON envelope.
    pub async fn search_fax_area_code_usa_raw(
        &self,
        params: &SearchFAXAreaCodeUSAParams,
    ) -> Result<Value> {
        self.call_raw("searchFaxAreaCodeUSA", params).await
    }

    /// \- Searches for USA/Canada Toll Free Numbers using a Search Criteria.
    /// \- Shows all USA/Canada Toll Free Numbers available if no criteria is
    /// provided.
    ///
    /// Call the `searchTollFreeCanUS` API method and deserialize into [`SearchTollFreeCANUSResponse`].
    pub async fn search_toll_free_can_us(
        &self,
        params: &SearchTollFreeCANUSParams,
    ) -> Result<SearchTollFreeCANUSResponse> {
        self.call("searchTollFreeCanUS", params).await
    }

    /// Call the `searchTollFreeCanUS` API method and return the raw JSON envelope.
    pub async fn search_toll_free_can_us_raw(
        &self,
        params: &SearchTollFreeCANUSParams,
    ) -> Result<Value> {
        self.call_raw("searchTollFreeCanUS", params).await
    }

    /// \- Searches for USA Toll Free Numbers using a Search Criteria.
    /// \- Shows all USA Toll Free Numbers available if no criteria is provided.
    ///
    /// Call the `searchTollFreeUSA` API method and deserialize into [`SearchTollFreeUSAResponse`].
    pub async fn search_toll_free_usa(
        &self,
        params: &SearchTollFreeUSAParams,
    ) -> Result<SearchTollFreeUSAResponse> {
        self.call("searchTollFreeUSA", params).await
    }

    /// Call the `searchTollFreeUSA` API method and return the raw JSON envelope.
    pub async fn search_toll_free_usa_raw(
        &self,
        params: &SearchTollFreeUSAParams,
    ) -> Result<Value> {
        self.call_raw("searchTollFreeUSA", params).await
    }

    /// \- Searches for Vanity Toll Free Numbers using a Search Criteria.
    ///
    /// Call the `searchVanity` API method and deserialize into [`SearchVanityResponse`].
    pub async fn search_vanity(&self, params: &SearchVanityParams) -> Result<SearchVanityResponse> {
        self.call("searchVanity", params).await
    }

    /// Call the `searchVanity` API method and return the raw JSON envelope.
    pub async fn search_vanity_raw(&self, params: &SearchVanityParams) -> Result<Value> {
        self.call_raw("searchVanity", params).await
    }

    /// \- Send information and audio file to email account.
    ///
    /// Call the `sendCallRecordingEmail` API method and deserialize into [`SendCallRecordingEmailResponse`].
    pub async fn send_call_recording_email(
        &self,
        params: &SendCallRecordingEmailParams,
    ) -> Result<SendCallRecordingEmailResponse> {
        self.call("sendCallRecordingEmail", params).await
    }

    /// Call the `sendCallRecordingEmail` API method and return the raw JSON envelope.
    pub async fn send_call_recording_email_raw(
        &self,
        params: &SendCallRecordingEmailParams,
    ) -> Result<Value> {
        self.call_raw("sendCallRecordingEmail", params).await
    }

    /// \- Send a Fax message to a Destination Number.
    ///
    /// Call the `sendFaxMessage` API method and deserialize into [`SendFAXMessageResponse`].
    pub async fn send_fax_message(
        &self,
        params: &SendFAXMessageParams,
    ) -> Result<SendFAXMessageResponse> {
        self.call("sendFaxMessage", params).await
    }

    /// Call the `sendFaxMessage` API method and return the raw JSON envelope.
    pub async fn send_fax_message_raw(&self, params: &SendFAXMessageParams) -> Result<Value> {
        self.call_raw("sendFaxMessage", params).await
    }

    /// \- Send a MMS message to a Destination Number.
    ///
    /// Call the `sendMMS` API method and deserialize into [`SendMMSResponse`].
    pub async fn send_mms(&self, params: &SendMMSParams) -> Result<SendMMSResponse> {
        self.call("sendMMS", params).await
    }

    /// Call the `sendMMS` API method and return the raw JSON envelope.
    pub async fn send_mms_raw(&self, params: &SendMMSParams) -> Result<Value> {
        self.call_raw("sendMMS", params).await
    }

    /// \- Send a SMS message to a Destination Number.
    ///
    /// Call the `sendSMS` API method and deserialize into [`SendSMSResponse`].
    pub async fn send_sms(&self, params: &SendSMSParams) -> Result<SendSMSResponse> {
        self.call("sendSMS", params).await
    }

    /// Call the `sendSMS` API method and return the raw JSON envelope.
    pub async fn send_sms_raw(&self, params: &SendSMSParams) -> Result<Value> {
        self.call_raw("sendSMS", params).await
    }

    /// \- Send a Voicemail Message File to an Email Address.
    ///
    /// Call the `sendVoicemailEmail` API method and deserialize into [`SendVoicemailEmailResponse`].
    pub async fn send_voicemail_email(
        &self,
        params: &SendVoicemailEmailParams,
    ) -> Result<SendVoicemailEmailResponse> {
        self.call("sendVoicemailEmail", params).await
    }

    /// Call the `sendVoicemailEmail` API method and return the raw JSON envelope.
    pub async fn send_voicemail_email_raw(
        &self,
        params: &SendVoicemailEmailParams,
    ) -> Result<Value> {
        self.call_raw("sendVoicemailEmail", params).await
    }

    /// \- Updates a specific Call Hunting if a Call Hunting code is provided.
    /// \- Adds a new Call Hunting if no Call Hunting code is provided.
    ///
    /// Call the `setCallHunting` API method and deserialize into [`SetCallHuntingResponse`].
    pub async fn set_call_hunting(
        &self,
        params: &SetCallHuntingParams,
    ) -> Result<SetCallHuntingResponse> {
        self.call("setCallHunting", params).await
    }

    /// Call the `setCallHunting` API method and return the raw JSON envelope.
    pub async fn set_call_hunting_raw(&self, params: &SetCallHuntingParams) -> Result<Value> {
        self.call_raw("setCallHunting", params).await
    }

    /// \- Updates a specific Call Parking entry if a Call Parking ID is
    /// provided.
    /// \- Adds a new Call Parking entry if no Call Parking ID is provided.
    ///
    /// Call the `setCallParking` API method and deserialize into [`SetCallParkingResponse`].
    pub async fn set_call_parking(
        &self,
        params: &SetCallParkingParams,
    ) -> Result<SetCallParkingResponse> {
        self.call("setCallParking", params).await
    }

    /// Call the `setCallParking` API method and return the raw JSON envelope.
    pub async fn set_call_parking_raw(&self, params: &SetCallParkingParams) -> Result<Value> {
        self.call_raw("setCallParking", params).await
    }

    /// \- Updates a specific Callback if a callback code is provided.
    /// \- Adds a new Callback entry if no callback code is provided.
    ///
    /// Call the `setCallback` API method and deserialize into [`SetCallbackResponse`].
    pub async fn set_callback(&self, params: &SetCallbackParams) -> Result<SetCallbackResponse> {
        self.call("setCallback", params).await
    }

    /// Call the `setCallback` API method and return the raw JSON envelope.
    pub async fn set_callback_raw(&self, params: &SetCallbackParams) -> Result<Value> {
        self.call_raw("setCallback", params).await
    }

    /// \- Updates a specific Caller ID Filtering if a filtering code is
    /// provided.
    /// \- Adds a new Caller ID Filtering if no filtering code is provided.
    ///
    /// Call the `setCallerIDFiltering` API method and deserialize into [`SetCallerIDFilteringResponse`].
    pub async fn set_caller_id_filtering(
        &self,
        params: &SetCallerIDFilteringParams,
    ) -> Result<SetCallerIDFilteringResponse> {
        self.call("setCallerIDFiltering", params).await
    }

    /// Call the `setCallerIDFiltering` API method and return the raw JSON envelope.
    pub async fn set_caller_id_filtering_raw(
        &self,
        params: &SetCallerIDFilteringParams,
    ) -> Result<Value> {
        self.call_raw("setCallerIDFiltering", params).await
    }

    /// \- Updates Reseller Client information.
    ///
    /// Call the `setClient` API method and deserialize into [`SetClientResponse`].
    pub async fn set_client(&self, params: &SetClientParams) -> Result<SetClientResponse> {
        self.call("setClient", params).await
    }

    /// Call the `setClient` API method and return the raw JSON envelope.
    pub async fn set_client_raw(&self, params: &SetClientParams) -> Result<Value> {
        self.call_raw("setClient", params).await
    }

    /// \- Update the Threshold Amount for a specific Reseller Client.- Update
    /// the Threshold notification e-mail for a specific Reseller Client if the
    /// e-mail address is provided.
    ///
    /// Call the `setClientThreshold` API method and deserialize into [`SetClientThresholdResponse`].
    pub async fn set_client_threshold(
        &self,
        params: &SetClientThresholdParams,
    ) -> Result<SetClientThresholdResponse> {
        self.call("setClientThreshold", params).await
    }

    /// Call the `setClientThreshold` API method and return the raw JSON envelope.
    pub async fn set_client_threshold_raw(
        &self,
        params: &SetClientThresholdParams,
    ) -> Result<Value> {
        self.call_raw("setClientThreshold", params).await
    }

    /// \- Updates a specific Conference if a conference code is provided.
    /// \- Adds a new Conference entry if no conference code is provided.
    ///
    /// Call the `setConference` API method and deserialize into [`SetConferenceResponse`].
    pub async fn set_conference(
        &self,
        params: &SetConferenceParams,
    ) -> Result<SetConferenceResponse> {
        self.call("setConference", params).await
    }

    /// Call the `setConference` API method and return the raw JSON envelope.
    pub async fn set_conference_raw(&self, params: &SetConferenceParams) -> Result<Value> {
        self.call_raw("setConference", params).await
    }

    /// \- Updates a specific Member profile if a member code is provided.
    /// \- Adds a new Member profile entry if no member code is provided.
    ///
    /// Call the `setConferenceMember` API method and deserialize into [`SetConferenceMemberResponse`].
    pub async fn set_conference_member(
        &self,
        params: &SetConferenceMemberParams,
    ) -> Result<SetConferenceMemberResponse> {
        self.call("setConferenceMember", params).await
    }

    /// Call the `setConferenceMember` API method and return the raw JSON envelope.
    pub async fn set_conference_member_raw(
        &self,
        params: &SetConferenceMemberParams,
    ) -> Result<Value> {
        self.call_raw("setConferenceMember", params).await
    }

    /// \- Updates the Billing Plan from a specific DID.
    ///
    /// Call the `setDIDBillingType` API method and deserialize into [`SetDIDBillingTypeResponse`].
    pub async fn set_did_billing_type(
        &self,
        params: &SetDIDBillingTypeParams,
    ) -> Result<SetDIDBillingTypeResponse> {
        self.call("setDIDBillingType", params).await
    }

    /// Call the `setDIDBillingType` API method and return the raw JSON envelope.
    pub async fn set_did_billing_type_raw(
        &self,
        params: &SetDIDBillingTypeParams,
    ) -> Result<Value> {
        self.call_raw("setDIDBillingType", params).await
    }

    /// \- Updates the information from a specific DID.
    ///
    /// Call the `setDIDInfo` API method and deserialize into [`SetDIDInfoResponse`].
    pub async fn set_did_info(&self, params: &SetDIDInfoParams) -> Result<SetDIDInfoResponse> {
        self.call("setDIDInfo", params).await
    }

    /// Call the `setDIDInfo` API method and return the raw JSON envelope.
    pub async fn set_did_info_raw(&self, params: &SetDIDInfoParams) -> Result<Value> {
        self.call_raw("setDIDInfo", params).await
    }

    /// \- Updates the POP from a specific DID.
    ///
    /// Call the `setDIDPOP` API method and deserialize into [`SetDIDPOPResponse`].
    pub async fn set_did_pop(&self, params: &SetDIDPOPParams) -> Result<SetDIDPOPResponse> {
        self.call("setDIDPOP", params).await
    }

    /// Call the `setDIDPOP` API method and return the raw JSON envelope.
    pub async fn set_did_pop_raw(&self, params: &SetDIDPOPParams) -> Result<Value> {
        self.call_raw("setDIDPOP", params).await
    }

    /// \- Updates the Routing from a specific DID.
    ///
    /// Call the `setDIDRouting` API method and deserialize into [`SetDIDRoutingResponse`].
    pub async fn set_did_routing(
        &self,
        params: &SetDIDRoutingParams,
    ) -> Result<SetDIDRoutingResponse> {
        self.call("setDIDRouting", params).await
    }

    /// Call the `setDIDRouting` API method and return the raw JSON envelope.
    pub async fn set_did_routing_raw(&self, params: &SetDIDRoutingParams) -> Result<Value> {
        self.call_raw("setDIDRouting", params).await
    }

    /// \- Updates the Voicemail from a specific DID.
    ///
    /// Call the `setDIDVoicemail` API method and deserialize into [`SetDIDVoicemailResponse`].
    pub async fn set_did_voicemail(
        &self,
        params: &SetDIDVoicemailParams,
    ) -> Result<SetDIDVoicemailResponse> {
        self.call("setDIDVoicemail", params).await
    }

    /// Call the `setDIDVoicemail` API method and return the raw JSON envelope.
    pub async fn set_did_voicemail_raw(&self, params: &SetDIDVoicemailParams) -> Result<Value> {
        self.call_raw("setDIDVoicemail", params).await
    }

    /// \- Updates a specific DISA if a disa code is provided.
    /// \- Adds a new DISA entry if no disa code is provided.
    ///
    /// Call the `setDISA` API method and deserialize into [`SetDISAResponse`].
    pub async fn set_disa(&self, params: &SetDISAParams) -> Result<SetDISAResponse> {
        self.call("setDISA", params).await
    }

    /// Call the `setDISA` API method and return the raw JSON envelope.
    pub async fn set_disa_raw(&self, params: &SetDISAParams) -> Result<Value> {
        self.call_raw("setDISA", params).await
    }

    /// \- Create or update the information of a specific "Email to Fax
    /// configuration".
    ///
    /// Call the `setEmailToFax` API method and deserialize into [`SetEmailToFAXResponse`].
    pub async fn set_email_to_fax(
        &self,
        params: &SetEmailToFAXParams,
    ) -> Result<SetEmailToFAXResponse> {
        self.call("setEmailToFax", params).await
    }

    /// Call the `setEmailToFax` API method and return the raw JSON envelope.
    pub async fn set_email_to_fax_raw(&self, params: &SetEmailToFAXParams) -> Result<Value> {
        self.call_raw("setEmailToFax", params).await
    }

    /// \- Create or update the information of a specific Fax Folder.
    ///
    /// Call the `setFaxFolder` API method and deserialize into [`SetFAXFolderResponse`].
    pub async fn set_fax_folder(
        &self,
        params: &SetFAXFolderParams,
    ) -> Result<SetFAXFolderResponse> {
        self.call("setFaxFolder", params).await
    }

    /// Call the `setFaxFolder` API method and return the raw JSON envelope.
    pub async fn set_fax_folder_raw(&self, params: &SetFAXFolderParams) -> Result<Value> {
        self.call_raw("setFaxFolder", params).await
    }

    /// \- Updates the email configuration from a specific Fax Number.
    ///
    /// Call the `setFaxNumberEmail` API method and deserialize into [`SetFAXNumberEmailResponse`].
    pub async fn set_fax_number_email(
        &self,
        params: &SetFAXNumberEmailParams,
    ) -> Result<SetFAXNumberEmailResponse> {
        self.call("setFaxNumberEmail", params).await
    }

    /// Call the `setFaxNumberEmail` API method and return the raw JSON envelope.
    pub async fn set_fax_number_email_raw(
        &self,
        params: &SetFAXNumberEmailParams,
    ) -> Result<Value> {
        self.call_raw("setFaxNumberEmail", params).await
    }

    /// \- Updates the information from a specific Fax Number.
    ///
    /// Call the `setFaxNumberInfo` API method and deserialize into [`SetFAXNumberInfoResponse`].
    pub async fn set_fax_number_info(
        &self,
        params: &SetFAXNumberInfoParams,
    ) -> Result<SetFAXNumberInfoResponse> {
        self.call("setFaxNumberInfo", params).await
    }

    /// Call the `setFaxNumberInfo` API method and return the raw JSON envelope.
    pub async fn set_fax_number_info_raw(&self, params: &SetFAXNumberInfoParams) -> Result<Value> {
        self.call_raw("setFaxNumberInfo", params).await
    }

    /// \- Updates the url callback configuration from a specific Fax Number.
    ///
    /// Call the `setFaxNumberURLCallback` API method and deserialize into [`SetFAXNumberURLCallbackResponse`].
    pub async fn set_fax_number_url_callback(
        &self,
        params: &SetFAXNumberURLCallbackParams,
    ) -> Result<SetFAXNumberURLCallbackResponse> {
        self.call("setFaxNumberURLCallback", params).await
    }

    /// Call the `setFaxNumberURLCallback` API method and return the raw JSON envelope.
    pub async fn set_fax_number_url_callback_raw(
        &self,
        params: &SetFAXNumberURLCallbackParams,
    ) -> Result<Value> {
        self.call_raw("setFaxNumberURLCallback", params).await
    }

    /// \- Updates a specific Forwarding if a fwd code is provided.
    /// \- Adds a new Forwarding entry if no fwd code is provided.
    ///
    /// Call the `setForwarding` API method and deserialize into [`SetForwardingResponse`].
    pub async fn set_forwarding(
        &self,
        params: &SetForwardingParams,
    ) -> Result<SetForwardingResponse> {
        self.call("setForwarding", params).await
    }

    /// Call the `setForwarding` API method and return the raw JSON envelope.
    pub async fn set_forwarding_raw(&self, params: &SetForwardingParams) -> Result<Value> {
        self.call_raw("setForwarding", params).await
    }

    /// \- Updates a specific IVR if an IVR code is provided.
    /// \- Adds a new IVR entry if no IVR code is provided.
    ///
    /// Call the `setIVR` API method and deserialize into [`SetIVRResponse`].
    pub async fn set_ivr(&self, params: &SetIVRParams) -> Result<SetIVRResponse> {
        self.call("setIVR", params).await
    }

    /// Call the `setIVR` API method and return the raw JSON envelope.
    pub async fn set_ivr_raw(&self, params: &SetIVRParams) -> Result<Value> {
        self.call_raw("setIVR", params).await
    }

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

    /// Call the `setLocation` API method and return the raw JSON envelope.
    pub async fn set_location_raw(&self, params: &SetLocationParams) -> Result<Value> {
        self.call_raw("setLocation", params).await
    }

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

    /// Call the `setMusicOnHold` API method and return the raw JSON envelope.
    pub async fn set_music_on_hold_raw(&self, params: &SetMusicOnHoldParams) -> Result<Value> {
        self.call_raw("setMusicOnHold", params).await
    }

    /// \- Updates a specific Phonebook entry if a phonebook code is provided.
    /// \- Adds a new Phonebook entry if no phonebook code is provided.
    ///
    /// Call the `setPhonebook` API method and deserialize into [`SetPhonebookResponse`].
    pub async fn set_phonebook(&self, params: &SetPhonebookParams) -> Result<SetPhonebookResponse> {
        self.call("setPhonebook", params).await
    }

    /// Call the `setPhonebook` API method and return the raw JSON envelope.
    pub async fn set_phonebook_raw(&self, params: &SetPhonebookParams) -> Result<Value> {
        self.call_raw("setPhonebook", params).await
    }

    /// \- Updates a specific Phonebook group if a phonebook code is provided.
    /// \- Adds a new Phonebook group if no phonebook group code is provided.
    /// \- Assigns or modifies group members if a member list is provided
    ///
    /// Call the `setPhonebookGroup` API method and deserialize into [`SetPhonebookGroupResponse`].
    pub async fn set_phonebook_group(
        &self,
        params: &SetPhonebookGroupParams,
    ) -> Result<SetPhonebookGroupResponse> {
        self.call("setPhonebookGroup", params).await
    }

    /// Call the `setPhonebookGroup` API method and return the raw JSON envelope.
    pub async fn set_phonebook_group_raw(&self, params: &SetPhonebookGroupParams) -> Result<Value> {
        self.call_raw("setPhonebookGroup", params).await
    }

    /// \- Updates a specific Queue entry if a queue code is provided.
    /// \- Adds a new Queue entry if no queue code is provided.
    ///
    /// Call the `setQueue` API method and deserialize into [`SetQueueResponse`].
    pub async fn set_queue(&self, params: &SetQueueParams) -> Result<SetQueueResponse> {
        self.call("setQueue", params).await
    }

    /// Call the `setQueue` API method and return the raw JSON envelope.
    pub async fn set_queue_raw(&self, params: &SetQueueParams) -> Result<Value> {
        self.call_raw("setQueue", params).await
    }

    /// \- Updates a specific Recording File if a Recording ID is provided.
    /// \- Adds a new Recording file entry if no Recording ID is provided.
    ///
    /// Call the `setRecording` API method and deserialize into [`SetRecordingResponse`].
    pub async fn set_recording(&self, params: &SetRecordingParams) -> Result<SetRecordingResponse> {
        self.call("setRecording", params).await
    }

    /// Call the `setRecording` API method and return the raw JSON envelope.
    pub async fn set_recording_raw(&self, params: &SetRecordingParams) -> Result<Value> {
        self.call_raw("setRecording", params).await
    }

    /// \- Updates a specific Ring Group if a ring group code is provided.
    /// \- Adds a new Ring Group entry if no ring group code is provided.
    ///
    /// Call the `setRingGroup` API method and deserialize into [`SetRingGroupResponse`].
    pub async fn set_ring_group(
        &self,
        params: &SetRingGroupParams,
    ) -> Result<SetRingGroupResponse> {
        self.call("setRingGroup", params).await
    }

    /// Call the `setRingGroup` API method and return the raw JSON envelope.
    pub async fn set_ring_group_raw(&self, params: &SetRingGroupParams) -> Result<Value> {
        self.call_raw("setRingGroup", params).await
    }

    /// \- Updates a specific SIP URI if a SIP URI code is provided.
    /// \- Adds a new SIP URI entry if no SIP URI code is provided.
    ///
    /// Call the `setSIPURI` API method and deserialize into [`SetSIPURIResponse`].
    pub async fn set_sip_uri(&self, params: &SetSIPURIParams) -> Result<SetSIPURIResponse> {
        self.call("setSIPURI", params).await
    }

    /// Call the `setSIPURI` API method and return the raw JSON envelope.
    pub async fn set_sip_uri_raw(&self, params: &SetSIPURIParams) -> Result<Value> {
        self.call_raw("setSIPURI", params).await
    }

    /// \- Enable/Disable the SMS Service for a DID
    /// \- Change the SMS settings for a DID
    ///
    /// Call the `setSMS` API method and deserialize into [`SetSMSResponse`].
    pub async fn set_sms(&self, params: &SetSMSParams) -> Result<SetSMSResponse> {
        self.call("setSMS", params).await
    }

    /// Call the `setSMS` API method and return the raw JSON envelope.
    pub async fn set_sms_raw(&self, params: &SetSMSParams) -> Result<Value> {
        self.call_raw("setSMS", params).await
    }

    /// \- Updates a specific Member from queue if a Member code is provided.
    /// \- Adds a new Member to Queue if no Member code is provided.
    ///
    /// Call the `setStaticMember` API method and deserialize into [`SetStaticMemberResponse`].
    pub async fn set_static_member(
        &self,
        params: &SetStaticMemberParams,
    ) -> Result<SetStaticMemberResponse> {
        self.call("setStaticMember", params).await
    }

    /// Call the `setStaticMember` API method and return the raw JSON envelope.
    pub async fn set_static_member_raw(&self, params: &SetStaticMemberParams) -> Result<Value> {
        self.call_raw("setStaticMember", params).await
    }

    /// \- Updates Sub Account information.
    ///
    /// Call the `setSubAccount` API method and deserialize into [`SetSubAccountResponse`].
    pub async fn set_sub_account(
        &self,
        params: &SetSubAccountParams,
    ) -> Result<SetSubAccountResponse> {
        self.call("setSubAccount", params).await
    }

    /// Call the `setSubAccount` API method and return the raw JSON envelope.
    pub async fn set_sub_account_raw(&self, params: &SetSubAccountParams) -> Result<Value> {
        self.call_raw("setSubAccount", params).await
    }

    /// \- Updates a specific Time Condition if a time condition code is
    /// provided.
    /// \- Adds a new Time Condition entry if no time condition code is provided.
    ///
    /// Call the `setTimeCondition` API method and deserialize into [`SetTimeConditionResponse`].
    pub async fn set_time_condition(
        &self,
        params: &SetTimeConditionParams,
    ) -> Result<SetTimeConditionResponse> {
        self.call("setTimeCondition", params).await
    }

    /// Call the `setTimeCondition` API method and return the raw JSON envelope.
    pub async fn set_time_condition_raw(&self, params: &SetTimeConditionParams) -> Result<Value> {
        self.call_raw("setTimeCondition", params).await
    }

    /// \- Updates the information from a specific Voicemail.
    ///
    /// Call the `setVoicemail` API method and deserialize into [`SetVoicemailResponse`].
    pub async fn set_voicemail(&self, params: &SetVoicemailParams) -> Result<SetVoicemailResponse> {
        self.call("setVoicemail", params).await
    }

    /// Call the `setVoicemail` API method and return the raw JSON envelope.
    pub async fn set_voicemail_raw(&self, params: &SetVoicemailParams) -> Result<Value> {
        self.call_raw("setVoicemail", params).await
    }

    /// \- Signs a new Reseller Client to your Reseller Account.
    ///
    /// Call the `signupClient` API method and deserialize into [`SignupClientResponse`].
    pub async fn signup_client(&self, params: &SignupClientParams) -> Result<SignupClientResponse> {
        self.call("signupClient", params).await
    }

    /// Call the `signupClient` API method and return the raw JSON envelope.
    pub async fn signup_client_raw(&self, params: &SignupClientParams) -> Result<Value> {
        self.call_raw("signupClient", params).await
    }

    /// \- Unconnects specific DID from Reseller Client Sub Account.
    ///
    /// Call the `unconnectDID` API method and deserialize into [`UnconnectDIDResponse`].
    pub async fn unconnect_did(&self, params: &UnconnectDIDParams) -> Result<UnconnectDIDResponse> {
        self.call("unconnectDID", params).await
    }

    /// Call the `unconnectDID` API method and return the raw JSON envelope.
    pub async fn unconnect_did_raw(&self, params: &UnconnectDIDParams) -> Result<Value> {
        self.call_raw("unconnectDID", params).await
    }

    /// \- Unconnects specific FAX DID from Reseller Client Sub Account.
    ///
    /// Call the `unconnectFAX` API method and deserialize into [`UnconnectFAXResponse`].
    pub async fn unconnect_fax(&self, params: &UnconnectFAXParams) -> Result<UnconnectFAXResponse> {
        self.call("unconnectFAX", params).await
    }

    /// Call the `unconnectFAX` API method and return the raw JSON envelope.
    pub async fn unconnect_fax_raw(&self, params: &UnconnectFAXParams) -> Result<Value> {
        self.call_raw("unconnectFAX", params).await
    }
}