#[allow(unused_imports)]
pub use progenitor_middleware_client::{ByteStream, ClientInfo, Error, ResponseValue};
#[allow(unused_imports)]
use progenitor_middleware_client::{
    encode_path, ClientHooks, OperationInfo, RequestBuilderExt,
};
/// Types used as operation parameters and responses.
#[allow(clippy::all)]
pub mod types {
    #[allow(unused_imports)]
    use super::{ByteStream, ResponseValue};
    /// Error types.
    pub mod error {
        /// Error from a `TryFrom` or `FromStr` implementation.
        pub struct ConversionError(::std::borrow::Cow<'static, str>);
        impl ::std::error::Error for ConversionError {}
        impl ::std::fmt::Display for ConversionError {
            fn fmt(
                &self,
                f: &mut ::std::fmt::Formatter<'_>,
            ) -> Result<(), ::std::fmt::Error> {
                ::std::fmt::Display::fmt(&self.0, f)
            }
        }
        impl ::std::fmt::Debug for ConversionError {
            fn fmt(
                &self,
                f: &mut ::std::fmt::Formatter<'_>,
            ) -> Result<(), ::std::fmt::Error> {
                ::std::fmt::Debug::fmt(&self.0, f)
            }
        }
        impl From<&'static str> for ConversionError {
            fn from(value: &'static str) -> Self {
                Self(value.into())
            }
        }
        impl From<String> for ConversionError {
            fn from(value: String) -> Self {
                Self(value.into())
            }
        }
    }
    ///`AddressExposure`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "category",
    ///    "direction",
    ///    "exposureType",
    ///    "value"
    ///  ],
    ///  "properties": {
    ///    "category": {
    ///      "description": "DTO.KYT.ADDRESS_EXPOSURE.CATEGORY",
    ///      "examples": [
    ///        "exchange"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "direction": {
    ///      "description": "DTO.KYT.ADDRESS_EXPOSURE.DIRECTION",
    ///      "examples": [
    ///        "both_directions"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "exposureType": {
    ///      "description": "DTO.KYT.ADDRESS_EXPOSURE.EXPOSURE_TYPE",
    ///      "examples": [
    ///        "indirect"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "value": {
    ///      "description": "DTO.KYT.ADDRESS_EXPOSURE.VALUE",
    ///      "examples": [
    ///        "424895.68594"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct AddressExposure {
        ///DTO.KYT.ADDRESS_EXPOSURE.CATEGORY
        pub category: ::std::string::String,
        ///DTO.KYT.ADDRESS_EXPOSURE.DIRECTION
        pub direction: ::std::string::String,
        ///DTO.KYT.ADDRESS_EXPOSURE.EXPOSURE_TYPE
        #[serde(rename = "exposureType")]
        pub exposure_type: ::std::string::String,
        ///DTO.KYT.ADDRESS_EXPOSURE.VALUE
        pub value: ::std::string::String,
    }
    impl ::std::convert::From<&AddressExposure> for AddressExposure {
        fn from(value: &AddressExposure) -> Self {
            value.clone()
        }
    }
    impl AddressExposure {
        pub fn builder() -> builder::AddressExposure {
            Default::default()
        }
    }
    ///`AddressRiskResponseDto`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "address",
    ///    "addressIdentifications",
    ///    "addressType",
    ///    "cluster",
    ///    "exposures",
    ///    "risk",
    ///    "riskReason",
    ///    "status",
    ///    "triggers"
    ///  ],
    ///  "properties": {
    ///    "address": {
    ///      "description": "DTO.KYT.ADDRESS_RISK_RESPONSE.ADDRESS",
    ///      "examples": [
    ///        "0x0038AC785dfB6C82b2c9A7B3B6854e08a10cb9f1"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "addressIdentifications": {
    ///      "description": "DTO.KYT.ADDRESS_RISK_RESPONSE.ADDRESS_IDENTIFICATIONS",
    ///      "examples": [
    ///        []
    ///      ],
    ///      "type": "array",
    ///      "items": {
    ///        "type": "string"
    ///      }
    ///    },
    ///    "addressType": {
    ///      "description": "DTO.KYT.ADDRESS_RISK_RESPONSE.ADDRESS_TYPE",
    ///      "examples": [
    ///        "PRIVATE_WALLET"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "cluster": {
    ///      "description": "DTO.KYT.ADDRESS_RISK_RESPONSE.CLUSTER",
    ///      "type": [
    ///        "string",
    ///        "null"
    ///      ]
    ///    },
    ///    "exposures": {
    ///      "description": "DTO.KYT.ADDRESS_RISK_RESPONSE.EXPOSURES",
    ///      "type": "array",
    ///      "items": {
    ///        "$ref": "#/components/schemas/AddressExposure"
    ///      }
    ///    },
    ///    "risk": {
    ///      "description": "DTO.KYT.ADDRESS_RISK_RESPONSE.RISK",
    ///      "examples": [
    ///        "Low"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "riskReason": {
    ///      "description": "DTO.KYT.ADDRESS_RISK_RESPONSE.RISK_REASON",
    ///      "type": [
    ///        "string",
    ///        "null"
    ///      ]
    ///    },
    ///    "status": {
    ///      "description": "DTO.KYT.ADDRESS_RISK_RESPONSE.STATUS",
    ///      "examples": [
    ///        "COMPLETE"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "triggers": {
    ///      "description": "DTO.KYT.ADDRESS_RISK_RESPONSE.TRIGGERS",
    ///      "examples": [
    ///        []
    ///      ],
    ///      "type": "array",
    ///      "items": {
    ///        "type": "string"
    ///      }
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct AddressRiskResponseDto {
        ///DTO.KYT.ADDRESS_RISK_RESPONSE.ADDRESS
        pub address: ::std::string::String,
        ///DTO.KYT.ADDRESS_RISK_RESPONSE.ADDRESS_IDENTIFICATIONS
        #[serde(rename = "addressIdentifications")]
        pub address_identifications: ::std::vec::Vec<::std::string::String>,
        ///DTO.KYT.ADDRESS_RISK_RESPONSE.ADDRESS_TYPE
        #[serde(rename = "addressType")]
        pub address_type: ::std::string::String,
        ///DTO.KYT.ADDRESS_RISK_RESPONSE.CLUSTER
        pub cluster: ::std::option::Option<::std::string::String>,
        ///DTO.KYT.ADDRESS_RISK_RESPONSE.EXPOSURES
        pub exposures: ::std::vec::Vec<AddressExposure>,
        ///DTO.KYT.ADDRESS_RISK_RESPONSE.RISK
        pub risk: ::std::string::String,
        ///DTO.KYT.ADDRESS_RISK_RESPONSE.RISK_REASON
        #[serde(rename = "riskReason")]
        pub risk_reason: ::std::option::Option<::std::string::String>,
        ///DTO.KYT.ADDRESS_RISK_RESPONSE.STATUS
        pub status: ::std::string::String,
        ///DTO.KYT.ADDRESS_RISK_RESPONSE.TRIGGERS
        pub triggers: ::std::vec::Vec<::std::string::String>,
    }
    impl ::std::convert::From<&AddressRiskResponseDto> for AddressRiskResponseDto {
        fn from(value: &AddressRiskResponseDto) -> Self {
            value.clone()
        }
    }
    impl AddressRiskResponseDto {
        pub fn builder() -> builder::AddressRiskResponseDto {
            Default::default()
        }
    }
    ///`AlertDetail`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "alertAmount",
    ///    "alertLevel",
    ///    "categoryId",
    ///    "exposureType",
    ///    "externalId",
    ///    "memo",
    ///    "service"
    ///  ],
    ///  "properties": {
    ///    "alertAmount": {
    ///      "description": "DTO.KYT.ALERT_DETAIL.ALERT_AMOUNT",
    ///      "examples": [
    ///        "8868.24"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "alertLevel": {
    ///      "description": "DTO.KYT.ALERT_DETAIL.ALERT_LEVEL",
    ///      "examples": [
    ///        "SEVERE"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "categoryId": {
    ///      "description": "DTO.KYT.ALERT_DETAIL.CATEGORY_ID",
    ///      "examples": [
    ///        3
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "exposureType": {
    ///      "description": "DTO.KYT.ALERT_DETAIL.EXPOSURE_TYPE",
    ///      "examples": [
    ///        "DIRECT"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "externalId": {
    ///      "description": "DTO.KYT.ALERT_DETAIL.EXTERNAL_ID",
    ///      "examples": [
    ///        "b7d17de0-f890-11ec-83bd-c37b1b9f5365"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "memo": {
    ///      "description": "DTO.KYT.ALERT_DETAIL.MEMO",
    ///      "type": [
    ///        "string",
    ///        "null"
    ///      ]
    ///    },
    ///    "service": {
    ///      "description": "DTO.KYT.ALERT_DETAIL.SERVICE",
    ///      "examples": [
    ///        "OFAC SDN Blender.io 2022-05-06"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct AlertDetail {
        ///DTO.KYT.ALERT_DETAIL.ALERT_AMOUNT
        #[serde(rename = "alertAmount")]
        pub alert_amount: ::std::string::String,
        ///DTO.KYT.ALERT_DETAIL.ALERT_LEVEL
        #[serde(rename = "alertLevel")]
        pub alert_level: ::std::string::String,
        ///DTO.KYT.ALERT_DETAIL.CATEGORY_ID
        #[serde(rename = "categoryId")]
        pub category_id: i64,
        ///DTO.KYT.ALERT_DETAIL.EXPOSURE_TYPE
        #[serde(rename = "exposureType")]
        pub exposure_type: ::std::string::String,
        ///DTO.KYT.ALERT_DETAIL.EXTERNAL_ID
        #[serde(rename = "externalId")]
        pub external_id: ::std::string::String,
        ///DTO.KYT.ALERT_DETAIL.MEMO
        pub memo: ::std::option::Option<::std::string::String>,
        ///DTO.KYT.ALERT_DETAIL.SERVICE
        pub service: ::std::string::String,
    }
    impl ::std::convert::From<&AlertDetail> for AlertDetail {
        fn from(value: &AlertDetail) -> Self {
            value.clone()
        }
    }
    impl AlertDetail {
        pub fn builder() -> builder::AlertDetail {
            Default::default()
        }
    }
    ///`AlteryaIdentification`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "address",
    ///    "chain",
    ///    "labels",
    ///    "object",
    ///    "on_chain_activity",
    ///    "reason",
    ///    "risk_level",
    ///    "risk_score"
    ///  ],
    ///  "properties": {
    ///    "address": {
    ///      "description": "DTO.KYT.ALTERYA_IDENTIFICATION.ADDRESS",
    ///      "examples": [
    ///        "0x8878ebb38c617b48630dca8d4af5ab788a3f94c5"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "chain": {
    ///      "description": "DTO.KYT.ALTERYA_IDENTIFICATION.CHAIN",
    ///      "examples": [
    ///        "eth"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "labels": {
    ///      "description": "DTO.KYT.ALTERYA_IDENTIFICATION.LABELS",
    ///      "examples": [
    ///        [
    ///          "scam",
    ///          "disputed"
    ///        ]
    ///      ],
    ///      "type": "array",
    ///      "items": {
    ///        "type": "string"
    ///      }
    ///    },
    ///    "object": {
    ///      "description": "DTO.KYT.ALTERYA_IDENTIFICATION.OBJECT",
    ///      "examples": [
    ///        "address_risk_response"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "on_chain_activity": {
    ///      "description": "DTO.KYT.ALTERYA_IDENTIFICATION.ON_CHAIN_ACTIVITY",
    ///      "allOf": [
    ///        {
    ///          "$ref": "#/components/schemas/OnChainActivity"
    ///        }
    ///      ]
    ///    },
    ///    "reason": {
    ///      "description": "DTO.KYT.ALTERYA_IDENTIFICATION.REASON",
    ///      "examples": [
    ///        "scam"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "risk_level": {
    ///      "description": "DTO.KYT.ALTERYA_IDENTIFICATION.RISK_LEVEL",
    ///      "examples": [
    ///        "severe"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "risk_score": {
    ///      "description": "DTO.KYT.ALTERYA_IDENTIFICATION.RISK_SCORE",
    ///      "examples": [
    ///        "99.99"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct AlteryaIdentification {
        ///DTO.KYT.ALTERYA_IDENTIFICATION.ADDRESS
        pub address: ::std::string::String,
        ///DTO.KYT.ALTERYA_IDENTIFICATION.CHAIN
        pub chain: ::std::string::String,
        ///DTO.KYT.ALTERYA_IDENTIFICATION.LABELS
        pub labels: ::std::vec::Vec<::std::string::String>,
        ///DTO.KYT.ALTERYA_IDENTIFICATION.OBJECT
        pub object: ::std::string::String,
        ///DTO.KYT.ALTERYA_IDENTIFICATION.ON_CHAIN_ACTIVITY
        pub on_chain_activity: OnChainActivity,
        ///DTO.KYT.ALTERYA_IDENTIFICATION.REASON
        pub reason: ::std::string::String,
        ///DTO.KYT.ALTERYA_IDENTIFICATION.RISK_LEVEL
        pub risk_level: ::std::string::String,
        ///DTO.KYT.ALTERYA_IDENTIFICATION.RISK_SCORE
        pub risk_score: ::std::string::String,
    }
    impl ::std::convert::From<&AlteryaIdentification> for AlteryaIdentification {
        fn from(value: &AlteryaIdentification) -> Self {
            value.clone()
        }
    }
    impl AlteryaIdentification {
        pub fn builder() -> builder::AlteryaIdentification {
            Default::default()
        }
    }
    ///`BalanceChangeType`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "string",
    ///  "enum": [
    ///    "INCREASE",
    ///    "DECREASE"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum BalanceChangeType {
        #[serde(rename = "INCREASE")]
        Increase,
        #[serde(rename = "DECREASE")]
        Decrease,
    }
    impl ::std::convert::From<&Self> for BalanceChangeType {
        fn from(value: &BalanceChangeType) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for BalanceChangeType {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::Increase => f.write_str("INCREASE"),
                Self::Decrease => f.write_str("DECREASE"),
            }
        }
    }
    impl ::std::str::FromStr for BalanceChangeType {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "INCREASE" => Ok(Self::Increase),
                "DECREASE" => Ok(Self::Decrease),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for BalanceChangeType {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String> for BalanceChangeType {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for BalanceChangeType {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    ///`BalanceTokenType`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "string",
    ///  "enum": [
    ///    "SOL",
    ///    "SPL"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum BalanceTokenType {
        #[serde(rename = "SOL")]
        Sol,
        #[serde(rename = "SPL")]
        Spl,
    }
    impl ::std::convert::From<&Self> for BalanceTokenType {
        fn from(value: &BalanceTokenType) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for BalanceTokenType {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::Sol => f.write_str("SOL"),
                Self::Spl => f.write_str("SPL"),
            }
        }
    }
    impl ::std::str::FromStr for BalanceTokenType {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "SOL" => Ok(Self::Sol),
                "SPL" => Ok(Self::Spl),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for BalanceTokenType {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String> for BalanceTokenType {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for BalanceTokenType {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    ///`BalanceUpdateDto`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "accountOwnerAddress",
    ///    "balanceChange",
    ///    "balanceChangeInNative",
    ///    "balanceChangeInUsd",
    ///    "blockHash",
    ///    "blockHeight",
    ///    "blockSlot",
    ///    "blockTimestamp",
    ///    "changeType",
    ///    "index",
    ///    "postBalance",
    ///    "postBalanceInNative",
    ///    "postBalanceInUsd",
    ///    "preBalance",
    ///    "preBalanceInNative",
    ///    "preBalanceInUsd",
    ///    "tokenAccountAddress",
    ///    "tokenAddress",
    ///    "transactionSignature",
    ///    "type"
    ///  ],
    ///  "properties": {
    ///    "accountOwnerAddress": {
    ///      "description": "DTO.WALLET.BALANCE_UPDATE.ACCOUNT_OWNER_ADDRESS",
    ///      "examples": [
    ///        "MJKqp326RZCHnAAbew9MDdui3iCKWco7fsK9sVuZTX2"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "balanceChange": {
    ///      "description": "DTO.WALLET.BALANCE_UPDATE.BALANCE_CHANGE",
    ///      "examples": [
    ///        "100.000000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "balanceChangeInNative": {
    ///      "description": "DTO.WALLET.BALANCE_UPDATE.BALANCE_CHANGE_IN_NATIVE",
    ///      "examples": [
    ///        "0.500000000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "balanceChangeInUsd": {
    ///      "description": "DTO.WALLET.BALANCE_UPDATE.BALANCE_CHANGE_IN_USD",
    ///      "examples": [
    ///        "123.34"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "blockHash": {
    ///      "description": "DTO.WALLET.BALANCE_UPDATE.BLOCK_HASH",
    ///      "examples": [
    ///        "5VERv8NMvzbJMEkV8xnrLkEaWRtSz9CosKDYjCJjBRnbJLgp8uirBgmQpjKhoR4tjF3ZpRzrFmBV6UjKdiSZkQUW"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "blockHeight": {
    ///      "description": "DTO.WALLET.BALANCE_UPDATE.BLOCK_HEIGHT",
    ///      "examples": [
    ///        123456789
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "blockSlot": {
    ///      "description": "DTO.WALLET.BALANCE_UPDATE.BLOCK_SLOT",
    ///      "examples": [
    ///        123456789
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "blockTimestamp": {
    ///      "description": "DTO.WALLET.BALANCE_UPDATE.BLOCK_TIMESTAMP",
    ///      "examples": [
    ///        1705312800000
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "changeType": {
    ///      "description": "DTO.WALLET.BALANCE_UPDATE.CHANGE_TYPE",
    ///      "examples": [
    ///        "INCREASE"
    ///      ],
    ///      "allOf": [
    ///        {
    ///          "$ref": "#/components/schemas/BalanceChangeType"
    ///        }
    ///      ]
    ///    },
    ///    "index": {
    ///      "description": "DTO.WALLET.BALANCE_UPDATE.INDEX",
    ///      "examples": [
    ///        0
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "postBalance": {
    ///      "description": "DTO.WALLET.BALANCE_UPDATE.POST_BALANCE",
    ///      "examples": [
    ///        "1100.123456"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "postBalanceInNative": {
    ///      "description": "DTO.WALLET.BALANCE_UPDATE.POST_BALANCE_IN_NATIVE",
    ///      "examples": [
    ///        "5.623456789"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "postBalanceInUsd": {
    ///      "description": "DTO.WALLET.BALANCE_UPDATE.POST_BALANCE_IN_USD",
    ///      "examples": [
    ///        "1357.90"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "preBalance": {
    ///      "description": "DTO.WALLET.BALANCE_UPDATE.PRE_BALANCE",
    ///      "examples": [
    ///        "1000.123456"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "preBalanceInNative": {
    ///      "description": "DTO.WALLET.BALANCE_UPDATE.PRE_BALANCE_IN_NATIVE",
    ///      "examples": [
    ///        "5.123456789"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "preBalanceInUsd": {
    ///      "description": "DTO.WALLET.BALANCE_UPDATE.PRE_BALANCE_IN_USD",
    ///      "examples": [
    ///        "1234.56"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "tokenAccountAddress": {
    ///      "description": "DTO.WALLET.BALANCE_UPDATE.TOKEN_ACCOUNT_ADDRESS",
    ///      "examples": [
    ///        "MJKqp326RZCHnAAbew9MDdui3iCKWco7fsK9sVuZTX2"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "tokenAddress": {
    ///      "description": "DTO.WALLET.BALANCE_UPDATE.TOKEN_ADDRESS",
    ///      "examples": [
    ///        "6p6xgHyF7AeE6TZkSmFsko444wqoP15icUSqi2jfGiPN"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "transactionSignature": {
    ///      "description": "DTO.WALLET.BALANCE_UPDATE.TRANSACTION_SIGNATURE",
    ///      "examples": [
    ///        "5VERv8NMvzbJMEkV8xnrLkEaWRtSz9CosKDYjCJjBRnbJLgp8uirBgmQpjKhoR4tjF3ZpRzrFmBV6UjKdiSZkQUW"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "type": {
    ///      "description": "DTO.WALLET.BALANCE_UPDATE.TYPE",
    ///      "examples": [
    ///        "SPL"
    ///      ],
    ///      "allOf": [
    ///        {
    ///          "$ref": "#/components/schemas/BalanceTokenType"
    ///        }
    ///      ]
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct BalanceUpdateDto {
        ///DTO.WALLET.BALANCE_UPDATE.ACCOUNT_OWNER_ADDRESS
        #[serde(rename = "accountOwnerAddress")]
        pub account_owner_address: ::std::string::String,
        ///DTO.WALLET.BALANCE_UPDATE.BALANCE_CHANGE
        #[serde(rename = "balanceChange")]
        pub balance_change: ::std::string::String,
        ///DTO.WALLET.BALANCE_UPDATE.BALANCE_CHANGE_IN_NATIVE
        #[serde(rename = "balanceChangeInNative")]
        pub balance_change_in_native: ::std::string::String,
        ///DTO.WALLET.BALANCE_UPDATE.BALANCE_CHANGE_IN_USD
        #[serde(rename = "balanceChangeInUsd")]
        pub balance_change_in_usd: ::std::string::String,
        ///DTO.WALLET.BALANCE_UPDATE.BLOCK_HASH
        #[serde(rename = "blockHash")]
        pub block_hash: ::std::string::String,
        ///DTO.WALLET.BALANCE_UPDATE.BLOCK_HEIGHT
        #[serde(rename = "blockHeight")]
        pub block_height: i64,
        ///DTO.WALLET.BALANCE_UPDATE.BLOCK_SLOT
        #[serde(rename = "blockSlot")]
        pub block_slot: i64,
        ///DTO.WALLET.BALANCE_UPDATE.BLOCK_TIMESTAMP
        #[serde(rename = "blockTimestamp")]
        pub block_timestamp: i64,
        ///DTO.WALLET.BALANCE_UPDATE.CHANGE_TYPE
        #[serde(rename = "changeType")]
        pub change_type: BalanceChangeType,
        ///DTO.WALLET.BALANCE_UPDATE.INDEX
        pub index: i64,
        ///DTO.WALLET.BALANCE_UPDATE.POST_BALANCE
        #[serde(rename = "postBalance")]
        pub post_balance: ::std::string::String,
        ///DTO.WALLET.BALANCE_UPDATE.POST_BALANCE_IN_NATIVE
        #[serde(rename = "postBalanceInNative")]
        pub post_balance_in_native: ::std::string::String,
        ///DTO.WALLET.BALANCE_UPDATE.POST_BALANCE_IN_USD
        #[serde(rename = "postBalanceInUsd")]
        pub post_balance_in_usd: ::std::string::String,
        ///DTO.WALLET.BALANCE_UPDATE.PRE_BALANCE
        #[serde(rename = "preBalance")]
        pub pre_balance: ::std::string::String,
        ///DTO.WALLET.BALANCE_UPDATE.PRE_BALANCE_IN_NATIVE
        #[serde(rename = "preBalanceInNative")]
        pub pre_balance_in_native: ::std::string::String,
        ///DTO.WALLET.BALANCE_UPDATE.PRE_BALANCE_IN_USD
        #[serde(rename = "preBalanceInUsd")]
        pub pre_balance_in_usd: ::std::string::String,
        ///DTO.WALLET.BALANCE_UPDATE.TOKEN_ACCOUNT_ADDRESS
        #[serde(rename = "tokenAccountAddress")]
        pub token_account_address: ::std::string::String,
        ///DTO.WALLET.BALANCE_UPDATE.TOKEN_ADDRESS
        #[serde(rename = "tokenAddress")]
        pub token_address: ::std::string::String,
        ///DTO.WALLET.BALANCE_UPDATE.TRANSACTION_SIGNATURE
        #[serde(rename = "transactionSignature")]
        pub transaction_signature: ::std::string::String,
        ///DTO.WALLET.BALANCE_UPDATE.TYPE
        #[serde(rename = "type")]
        pub type_: BalanceTokenType,
    }
    impl ::std::convert::From<&BalanceUpdateDto> for BalanceUpdateDto {
        fn from(value: &BalanceUpdateDto) -> Self {
            value.clone()
        }
    }
    impl BalanceUpdateDto {
        pub fn builder() -> builder::BalanceUpdateDto {
            Default::default()
        }
    }
    ///`BalanceUpdatePage`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "data",
    ///    "hasNext",
    ///    "hasPrev"
    ///  ],
    ///  "properties": {
    ///    "data": {
    ///      "description": "DTO.PAGE.DATA",
    ///      "type": "array",
    ///      "items": {
    ///        "$ref": "#/components/schemas/BalanceUpdateDTO"
    ///      }
    ///    },
    ///    "endCursor": {
    ///      "description": "DTO.PAGE.END_CURSOR",
    ///      "type": "string"
    ///    },
    ///    "hasNext": {
    ///      "description": "DTO.PAGE.HAS_NEXT",
    ///      "default": false,
    ///      "type": "boolean"
    ///    },
    ///    "hasPrev": {
    ///      "description": "DTO.PAGE.HAS_PREV",
    ///      "default": false,
    ///      "type": "boolean"
    ///    },
    ///    "startCursor": {
    ///      "description": "DTO.PAGE.START_CURSOR",
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct BalanceUpdatePage {
        ///DTO.PAGE.DATA
        pub data: ::std::vec::Vec<BalanceUpdateDto>,
        ///DTO.PAGE.END_CURSOR
        #[serde(
            rename = "endCursor",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub end_cursor: ::std::option::Option<::std::string::String>,
        ///DTO.PAGE.HAS_NEXT
        #[serde(rename = "hasNext")]
        pub has_next: bool,
        ///DTO.PAGE.HAS_PREV
        #[serde(rename = "hasPrev")]
        pub has_prev: bool,
        ///DTO.PAGE.START_CURSOR
        #[serde(
            rename = "startCursor",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub start_cursor: ::std::option::Option<::std::string::String>,
    }
    impl ::std::convert::From<&BalanceUpdatePage> for BalanceUpdatePage {
        fn from(value: &BalanceUpdatePage) -> Self {
            value.clone()
        }
    }
    impl BalanceUpdatePage {
        pub fn builder() -> builder::BalanceUpdatePage {
            Default::default()
        }
    }
    ///`BlockchainDto`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "chainId",
    ///    "explorerUrl",
    ///    "name",
    ///    "symbol"
    ///  ],
    ///  "properties": {
    ///    "chainId": {
    ///      "description": "DTO.BLOCKCHAIN.CHAIN_ID",
    ///      "examples": [
    ///        1
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "explorerUrl": {
    ///      "description": "DTO.BLOCKCHAIN.EXPLORER_URL",
    ///      "examples": [
    ///        "https://explorer.solana.com"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "name": {
    ///      "description": "DTO.BLOCKCHAIN.NAME",
    ///      "examples": [
    ///        "Solana"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "symbol": {
    ///      "description": "DTO.BLOCKCHAIN.SYMBOL",
    ///      "examples": [
    ///        "SOL"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct BlockchainDto {
        ///DTO.BLOCKCHAIN.CHAIN_ID
        #[serde(rename = "chainId")]
        pub chain_id: i64,
        ///DTO.BLOCKCHAIN.EXPLORER_URL
        #[serde(rename = "explorerUrl")]
        pub explorer_url: ::std::string::String,
        ///DTO.BLOCKCHAIN.NAME
        pub name: ::std::string::String,
        ///DTO.BLOCKCHAIN.SYMBOL
        pub symbol: ::std::string::String,
    }
    impl ::std::convert::From<&BlockchainDto> for BlockchainDto {
        fn from(value: &BlockchainDto) -> Self {
            value.clone()
        }
    }
    impl BlockchainDto {
        pub fn builder() -> builder::BlockchainDto {
            Default::default()
        }
    }
    ///`BlockchainLatestBlockDto`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "blockhash",
    ///    "lastValidBlockHeight"
    ///  ],
    ///  "properties": {
    ///    "blockhash": {
    ///      "description": "DTO.BLOCKCHAIN.LATEST_BLOCK.BLOCKHASH",
    ///      "examples": [
    ///        "123"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "lastValidBlockHeight": {
    ///      "description": "DTO.BLOCKCHAIN.LATEST_BLOCK.LAST_VALID_BLOCK_HEIGHT",
    ///      "examples": [
    ///        123
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct BlockchainLatestBlockDto {
        ///DTO.BLOCKCHAIN.LATEST_BLOCK.BLOCKHASH
        pub blockhash: ::std::string::String,
        ///DTO.BLOCKCHAIN.LATEST_BLOCK.LAST_VALID_BLOCK_HEIGHT
        #[serde(rename = "lastValidBlockHeight")]
        pub last_valid_block_height: i64,
    }
    impl ::std::convert::From<&BlockchainLatestBlockDto> for BlockchainLatestBlockDto {
        fn from(value: &BlockchainLatestBlockDto) -> Self {
            value.clone()
        }
    }
    impl BlockchainLatestBlockDto {
        pub fn builder() -> builder::BlockchainLatestBlockDto {
            Default::default()
        }
    }
    ///`BooleanResultDto`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "success"
    ///  ],
    ///  "properties": {
    ///    "success": {
    ///      "description": "DTO.BOOLEAN_RESULT.SUCCESS",
    ///      "examples": [
    ///        true
    ///      ],
    ///      "type": "boolean"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct BooleanResultDto {
        ///DTO.BOOLEAN_RESULT.SUCCESS
        pub success: bool,
    }
    impl ::std::convert::From<&BooleanResultDto> for BooleanResultDto {
        fn from(value: &BooleanResultDto) -> Self {
            value.clone()
        }
    }
    impl BooleanResultDto {
        pub fn builder() -> builder::BooleanResultDto {
            Default::default()
        }
    }
    ///`CalculatePnlInput`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "properties": {
    ///    "tokenAddresses": {
    ///      "description": "DTO.WALLET.CALCULATE_PNL.INPUT.TOKEN_ADDRESSES",
    ///      "examples": [
    ///        [
    ///          "6p6xgHyF7AeE6TZkSmFsko444wqoP15icUSqi2jfGiPN",
    ///          "6p6xgHyF7AeE6TZkSmFsko444wqoP15icUSqi2jfGiPN"
    ///        ]
    ///      ],
    ///      "type": "array",
    ///      "items": {
    ///        "type": "string"
    ///      }
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct CalculatePnlInput {
        ///DTO.WALLET.CALCULATE_PNL.INPUT.TOKEN_ADDRESSES
        #[serde(
            rename = "tokenAddresses",
            default,
            skip_serializing_if = "::std::vec::Vec::is_empty"
        )]
        pub token_addresses: ::std::vec::Vec<::std::string::String>,
    }
    impl ::std::convert::From<&CalculatePnlInput> for CalculatePnlInput {
        fn from(value: &CalculatePnlInput) -> Self {
            value.clone()
        }
    }
    impl ::std::default::Default for CalculatePnlInput {
        fn default() -> Self {
            Self {
                token_addresses: Default::default(),
            }
        }
    }
    impl CalculatePnlInput {
        pub fn builder() -> builder::CalculatePnlInput {
            Default::default()
        }
    }
    ///`Candle`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "close",
    ///    "high",
    ///    "low",
    ///    "open",
    ///    "resolution",
    ///    "time",
    ///    "trades",
    ///    "updatedAt",
    ///    "volume"
    ///  ],
    ///  "properties": {
    ///    "close": {
    ///      "description": "DTO.CANDLE.CLOSE",
    ///      "examples": [
    ///        "51.2"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "high": {
    ///      "description": "DTO.CANDLE.HIGH",
    ///      "examples": [
    ///        "51.8"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "low": {
    ///      "description": "DTO.CANDLE.LOW",
    ///      "examples": [
    ///        "50.1"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "open": {
    ///      "description": "DTO.CANDLE.OPEN",
    ///      "examples": [
    ///        "50.5"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "resolution": {
    ///      "description": "DTO.CANDLE.RESOLUTION",
    ///      "examples": [
    ///        "1h"
    ///      ],
    ///      "allOf": [
    ///        {
    ///          "$ref": "#/components/schemas/Resolution"
    ///        }
    ///      ]
    ///    },
    ///    "time": {
    ///      "description": "DTO.CANDLE.TIME",
    ///      "examples": [
    ///        1709251200000
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "trades": {
    ///      "description": "DTO.CANDLE.TRADES",
    ///      "examples": [
    ///        42
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "updatedAt": {
    ///      "description": "DTO.CANDLE.UPDATED_AT",
    ///      "examples": [
    ///        1709251200000
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "volume": {
    ///      "description": "DTO.CANDLE.VOLUME",
    ///      "examples": [
    ///        "1000000"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct Candle {
        ///DTO.CANDLE.CLOSE
        pub close: ::std::string::String,
        ///DTO.CANDLE.HIGH
        pub high: ::std::string::String,
        ///DTO.CANDLE.LOW
        pub low: ::std::string::String,
        ///DTO.CANDLE.OPEN
        pub open: ::std::string::String,
        ///DTO.CANDLE.RESOLUTION
        pub resolution: Resolution,
        ///DTO.CANDLE.TIME
        pub time: i64,
        ///DTO.CANDLE.TRADES
        pub trades: i64,
        ///DTO.CANDLE.UPDATED_AT
        #[serde(rename = "updatedAt")]
        pub updated_at: i64,
        ///DTO.CANDLE.VOLUME
        pub volume: ::std::string::String,
    }
    impl ::std::convert::From<&Candle> for Candle {
        fn from(value: &Candle) -> Self {
            value.clone()
        }
    }
    impl Candle {
        pub fn builder() -> builder::Candle {
            Default::default()
        }
    }
    ///`Chain`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "string",
    ///  "enum": [
    ///    "sol",
    ///    "bsc",
    ///    "eth"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum Chain {
        #[serde(rename = "sol")]
        Sol,
        #[serde(rename = "bsc")]
        Bsc,
        #[serde(rename = "eth")]
        Eth,
    }
    impl ::std::convert::From<&Self> for Chain {
        fn from(value: &Chain) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for Chain {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::Sol => f.write_str("sol"),
                Self::Bsc => f.write_str("bsc"),
                Self::Eth => f.write_str("eth"),
            }
        }
    }
    impl ::std::str::FromStr for Chain {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "sol" => Ok(Self::Sol),
                "bsc" => Ok(Self::Bsc),
                "eth" => Ok(Self::Eth),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for Chain {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String> for Chain {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for Chain {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    ///`ChainSymbol`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "string",
    ///  "enum": [
    ///    "sol",
    ///    "bsc",
    ///    "eth"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum ChainSymbol {
        #[serde(rename = "sol")]
        Sol,
        #[serde(rename = "bsc")]
        Bsc,
        #[serde(rename = "eth")]
        Eth,
    }
    impl ::std::convert::From<&Self> for ChainSymbol {
        fn from(value: &ChainSymbol) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for ChainSymbol {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::Sol => f.write_str("sol"),
                Self::Bsc => f.write_str("bsc"),
                Self::Eth => f.write_str("eth"),
            }
        }
    }
    impl ::std::str::FromStr for ChainSymbol {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "sol" => Ok(Self::Sol),
                "bsc" => Ok(Self::Bsc),
                "eth" => Ok(Self::Eth),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for ChainSymbol {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String> for ChainSymbol {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for ChainSymbol {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    ///`ChainalysisAddressIdentification`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "addressName",
    ///    "categoryId",
    ///    "description"
    ///  ],
    ///  "properties": {
    ///    "addressName": {
    ///      "description": "DTO.KYT.CHAINALYSIS_ADDRESS_IDENTIFICATION.ADDRESS_NAME",
    ///      "examples": [
    ///        "SANCTIONS: OFAC SDN: Xiaobing Yan"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "categoryId": {
    ///      "description": "DTO.KYT.CHAINALYSIS_ADDRESS_IDENTIFICATION.CATEGORY_ID",
    ///      "examples": [
    ///        3
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "description": {
    ///      "description": "DTO.KYT.CHAINALYSIS_ADDRESS_IDENTIFICATION.DESCRIPTION",
    ///      "examples": [
    ///        "This specific address 12QtD5BFwRsdNsAZY76UVE1xyCGNTojH9h within the cluster has been identified..."
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct ChainalysisAddressIdentification {
        ///DTO.KYT.CHAINALYSIS_ADDRESS_IDENTIFICATION.ADDRESS_NAME
        #[serde(rename = "addressName")]
        pub address_name: ::std::string::String,
        ///DTO.KYT.CHAINALYSIS_ADDRESS_IDENTIFICATION.CATEGORY_ID
        #[serde(rename = "categoryId")]
        pub category_id: i64,
        ///DTO.KYT.CHAINALYSIS_ADDRESS_IDENTIFICATION.DESCRIPTION
        pub description: ::std::string::String,
    }
    impl ::std::convert::From<&ChainalysisAddressIdentification>
    for ChainalysisAddressIdentification {
        fn from(value: &ChainalysisAddressIdentification) -> Self {
            value.clone()
        }
    }
    impl ChainalysisAddressIdentification {
        pub fn builder() -> builder::ChainalysisAddressIdentification {
            Default::default()
        }
    }
    ///`ClaimRedPacketInput`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "chain",
    ///    "claimer"
    ///  ],
    ///  "properties": {
    ///    "chain": {
    ///      "description": "DTO.RED_PACKET.CHAIN",
    ///      "examples": [
    ///        "sol"
    ///      ],
    ///      "type": "string",
    ///      "enum": [
    ///        "sol",
    ///        "bsc",
    ///        "eth"
    ///      ]
    ///    },
    ///    "claimer": {
    ///      "description": "DTO.RED_PACKET.CLAIMER",
    ///      "examples": [
    ///        "Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "packetId": {
    ///      "description": "DTO.RED_PACKET.PACKET_ID",
    ///      "examples": [
    ///        "Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "password": {
    ///      "description": "DTO.RED_PACKET.PASSWORD",
    ///      "examples": [
    ///        "123456"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "shareId": {
    ///      "description": "DTO.RED_PACKET.SHARE_ID",
    ///      "examples": [
    ///        "123456"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct ClaimRedPacketInput {
        ///DTO.RED_PACKET.CHAIN
        pub chain: ClaimRedPacketInputChain,
        ///DTO.RED_PACKET.CLAIMER
        pub claimer: ::std::string::String,
        ///DTO.RED_PACKET.PACKET_ID
        #[serde(
            rename = "packetId",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub packet_id: ::std::option::Option<::std::string::String>,
        ///DTO.RED_PACKET.PASSWORD
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub password: ::std::option::Option<::std::string::String>,
        ///DTO.RED_PACKET.SHARE_ID
        #[serde(
            rename = "shareId",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub share_id: ::std::option::Option<::std::string::String>,
    }
    impl ::std::convert::From<&ClaimRedPacketInput> for ClaimRedPacketInput {
        fn from(value: &ClaimRedPacketInput) -> Self {
            value.clone()
        }
    }
    impl ClaimRedPacketInput {
        pub fn builder() -> builder::ClaimRedPacketInput {
            Default::default()
        }
    }
    ///DTO.RED_PACKET.CHAIN
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "DTO.RED_PACKET.CHAIN",
    ///  "examples": [
    ///    "sol"
    ///  ],
    ///  "type": "string",
    ///  "enum": [
    ///    "sol",
    ///    "bsc",
    ///    "eth"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum ClaimRedPacketInputChain {
        #[serde(rename = "sol")]
        Sol,
        #[serde(rename = "bsc")]
        Bsc,
        #[serde(rename = "eth")]
        Eth,
    }
    impl ::std::convert::From<&Self> for ClaimRedPacketInputChain {
        fn from(value: &ClaimRedPacketInputChain) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for ClaimRedPacketInputChain {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::Sol => f.write_str("sol"),
                Self::Bsc => f.write_str("bsc"),
                Self::Eth => f.write_str("eth"),
            }
        }
    }
    impl ::std::str::FromStr for ClaimRedPacketInputChain {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "sol" => Ok(Self::Sol),
                "bsc" => Ok(Self::Bsc),
                "eth" => Ok(Self::Eth),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for ClaimRedPacketInputChain {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String> for ClaimRedPacketInputChain {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for ClaimRedPacketInputChain {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    ///`CreateEndpointInput`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "properties": {
    ///    "channels": {
    ///      "description": "DTO.ENDPOINT.CHANNELS",
    ///      "examples": [
    ///        [
    ///          "sol.token.migrated",
    ///          "sol.token.created"
    ///        ]
    ///      ],
    ///      "type": "array",
    ///      "items": {
    ///        "type": "string",
    ///        "enum": [
    ///          "sol.token.migrated",
    ///          "sol.token.created"
    ///        ]
    ///      }
    ///    },
    ///    "description": {
    ///      "description": "DTO.ENDPOINT.DESCRIPTION",
    ///      "examples": [
    ///        "Webhook description"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "disabled": {
    ///      "description": "DTO.ENDPOINT.DISABLED",
    ///      "default": false,
    ///      "type": "boolean"
    ///    },
    ///    "filter": {
    ///      "description": "DTO.ENDPOINT.FILTER",
    ///      "type": "string"
    ///    },
    ///    "filterTypes": {
    ///      "description": "DTO.ENDPOINT.FILTER_TYPES",
    ///      "type": "array",
    ///      "items": {
    ///        "type": "string"
    ///      }
    ///    },
    ///    "metadata": {
    ///      "description": "DTO.ENDPOINT.METADATA",
    ///      "examples": [
    ///        {
    ///          "key": "value"
    ///        }
    ///      ],
    ///      "type": "object"
    ///    },
    ///    "rateLimit": {
    ///      "description": "DTO.ENDPOINT.RATE_LIMIT",
    ///      "examples": [
    ///        1000
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "url": {
    ///      "description": "DTO.ENDPOINT.URL",
    ///      "examples": [
    ///        "https://example.com"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct CreateEndpointInput {
        ///DTO.ENDPOINT.CHANNELS
        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
        pub channels: ::std::vec::Vec<CreateEndpointInputChannelsItem>,
        ///DTO.ENDPOINT.DESCRIPTION
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub description: ::std::option::Option<::std::string::String>,
        ///DTO.ENDPOINT.DISABLED
        #[serde(default)]
        pub disabled: bool,
        ///DTO.ENDPOINT.FILTER
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub filter: ::std::option::Option<::std::string::String>,
        ///DTO.ENDPOINT.FILTER_TYPES
        #[serde(
            rename = "filterTypes",
            default,
            skip_serializing_if = "::std::vec::Vec::is_empty"
        )]
        pub filter_types: ::std::vec::Vec<::std::string::String>,
        ///DTO.ENDPOINT.METADATA
        #[serde(default, skip_serializing_if = "::serde_json::Map::is_empty")]
        pub metadata: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
        ///DTO.ENDPOINT.RATE_LIMIT
        #[serde(
            rename = "rateLimit",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub rate_limit: ::std::option::Option<i64>,
        ///DTO.ENDPOINT.URL
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub url: ::std::option::Option<::std::string::String>,
    }
    impl ::std::convert::From<&CreateEndpointInput> for CreateEndpointInput {
        fn from(value: &CreateEndpointInput) -> Self {
            value.clone()
        }
    }
    impl ::std::default::Default for CreateEndpointInput {
        fn default() -> Self {
            Self {
                channels: Default::default(),
                description: Default::default(),
                disabled: Default::default(),
                filter: Default::default(),
                filter_types: Default::default(),
                metadata: Default::default(),
                rate_limit: Default::default(),
                url: Default::default(),
            }
        }
    }
    impl CreateEndpointInput {
        pub fn builder() -> builder::CreateEndpointInput {
            Default::default()
        }
    }
    ///`CreateEndpointInputChannelsItem`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "string",
    ///  "enum": [
    ///    "sol.token.migrated",
    ///    "sol.token.created"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum CreateEndpointInputChannelsItem {
        #[serde(rename = "sol.token.migrated")]
        SolTokenMigrated,
        #[serde(rename = "sol.token.created")]
        SolTokenCreated,
    }
    impl ::std::convert::From<&Self> for CreateEndpointInputChannelsItem {
        fn from(value: &CreateEndpointInputChannelsItem) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for CreateEndpointInputChannelsItem {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::SolTokenMigrated => f.write_str("sol.token.migrated"),
                Self::SolTokenCreated => f.write_str("sol.token.created"),
            }
        }
    }
    impl ::std::str::FromStr for CreateEndpointInputChannelsItem {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "sol.token.migrated" => Ok(Self::SolTokenMigrated),
                "sol.token.created" => Ok(Self::SolTokenCreated),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for CreateEndpointInputChannelsItem {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String>
    for CreateEndpointInputChannelsItem {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String>
    for CreateEndpointInputChannelsItem {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    ///`CreateRedPacketInput`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "chain",
    ///    "creator",
    ///    "maxClaims",
    ///    "mint"
    ///  ],
    ///  "properties": {
    ///    "chain": {
    ///      "description": "DTO.RED_PACKET.CHAIN",
    ///      "examples": [
    ///        "sol"
    ///      ],
    ///      "type": "string",
    ///      "enum": [
    ///        "sol",
    ///        "bsc",
    ///        "eth"
    ///      ]
    ///    },
    ///    "claimAuthority": {
    ///      "description": "DTO.RED_PACKET.CLAIM_AUTHORITY",
    ///      "examples": [
    ///        "Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "creator": {
    ///      "description": "DTO.RED_PACKET.CREATOR",
    ///      "examples": [
    ///        "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"
    ///      ],
    ///      "type": "string",
    ///      "maxLength": 64,
    ///      "minLength": 8
    ///    },
    ///    "fixedAmount": {
    ///      "description": "DTO.RED_PACKET.FIXED_AMOUNT",
    ///      "examples": [
    ///        "1000000000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "maxClaims": {
    ///      "description": "DTO.RED_PACKET.MAX_CLAIMS",
    ///      "examples": [
    ///        10
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64",
    ///      "maximum": 100.0,
    ///      "minimum": 1.0
    ///    },
    ///    "memo": {
    ///      "description": "DTO.RED_PACKET.MEMO",
    ///      "examples": [
    ///        "Happy Red Packet"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "mint": {
    ///      "description": "DTO.RED_PACKET.MINT",
    ///      "examples": [
    ///        "Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "password": {
    ///      "description": "DTO.RED_PACKET.PASSWORD",
    ///      "examples": [
    ///        "123456"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "totalAmount": {
    ///      "description": "DTO.RED_PACKET.TOTAL_AMOUNT",
    ///      "examples": [
    ///        "1000000000"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct CreateRedPacketInput {
        ///DTO.RED_PACKET.CHAIN
        pub chain: CreateRedPacketInputChain,
        ///DTO.RED_PACKET.CLAIM_AUTHORITY
        #[serde(
            rename = "claimAuthority",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub claim_authority: ::std::option::Option<::std::string::String>,
        ///DTO.RED_PACKET.CREATOR
        pub creator: CreateRedPacketInputCreator,
        ///DTO.RED_PACKET.FIXED_AMOUNT
        #[serde(
            rename = "fixedAmount",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub fixed_amount: ::std::option::Option<::std::string::String>,
        ///DTO.RED_PACKET.MAX_CLAIMS
        #[serde(rename = "maxClaims")]
        pub max_claims: ::std::num::NonZeroU64,
        ///DTO.RED_PACKET.MEMO
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub memo: ::std::option::Option<::std::string::String>,
        ///DTO.RED_PACKET.MINT
        pub mint: ::std::string::String,
        ///DTO.RED_PACKET.PASSWORD
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub password: ::std::option::Option<::std::string::String>,
        ///DTO.RED_PACKET.TOTAL_AMOUNT
        #[serde(
            rename = "totalAmount",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub total_amount: ::std::option::Option<::std::string::String>,
    }
    impl ::std::convert::From<&CreateRedPacketInput> for CreateRedPacketInput {
        fn from(value: &CreateRedPacketInput) -> Self {
            value.clone()
        }
    }
    impl CreateRedPacketInput {
        pub fn builder() -> builder::CreateRedPacketInput {
            Default::default()
        }
    }
    ///DTO.RED_PACKET.CHAIN
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "DTO.RED_PACKET.CHAIN",
    ///  "examples": [
    ///    "sol"
    ///  ],
    ///  "type": "string",
    ///  "enum": [
    ///    "sol",
    ///    "bsc",
    ///    "eth"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum CreateRedPacketInputChain {
        #[serde(rename = "sol")]
        Sol,
        #[serde(rename = "bsc")]
        Bsc,
        #[serde(rename = "eth")]
        Eth,
    }
    impl ::std::convert::From<&Self> for CreateRedPacketInputChain {
        fn from(value: &CreateRedPacketInputChain) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for CreateRedPacketInputChain {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::Sol => f.write_str("sol"),
                Self::Bsc => f.write_str("bsc"),
                Self::Eth => f.write_str("eth"),
            }
        }
    }
    impl ::std::str::FromStr for CreateRedPacketInputChain {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "sol" => Ok(Self::Sol),
                "bsc" => Ok(Self::Bsc),
                "eth" => Ok(Self::Eth),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for CreateRedPacketInputChain {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String> for CreateRedPacketInputChain {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for CreateRedPacketInputChain {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    ///DTO.RED_PACKET.CREATOR
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "DTO.RED_PACKET.CREATOR",
    ///  "examples": [
    ///    "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"
    ///  ],
    ///  "type": "string",
    ///  "maxLength": 64,
    ///  "minLength": 8
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
    #[serde(transparent)]
    pub struct CreateRedPacketInputCreator(::std::string::String);
    impl ::std::ops::Deref for CreateRedPacketInputCreator {
        type Target = ::std::string::String;
        fn deref(&self) -> &::std::string::String {
            &self.0
        }
    }
    impl ::std::convert::From<CreateRedPacketInputCreator> for ::std::string::String {
        fn from(value: CreateRedPacketInputCreator) -> Self {
            value.0
        }
    }
    impl ::std::convert::From<&CreateRedPacketInputCreator>
    for CreateRedPacketInputCreator {
        fn from(value: &CreateRedPacketInputCreator) -> Self {
            value.clone()
        }
    }
    impl ::std::str::FromStr for CreateRedPacketInputCreator {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            if value.chars().count() > 64usize {
                return Err("longer than 64 characters".into());
            }
            if value.chars().count() < 8usize {
                return Err("shorter than 8 characters".into());
            }
            Ok(Self(value.to_string()))
        }
    }
    impl ::std::convert::TryFrom<&str> for CreateRedPacketInputCreator {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String>
    for CreateRedPacketInputCreator {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for CreateRedPacketInputCreator {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl<'de> ::serde::Deserialize<'de> for CreateRedPacketInputCreator {
        fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
        where
            D: ::serde::Deserializer<'de>,
        {
            ::std::string::String::deserialize(deserializer)?
                .parse()
                .map_err(|e: self::error::ConversionError| {
                    <D::Error as ::serde::de::Error>::custom(e.to_string())
                })
        }
    }
    ///`CreateRedPacketReply`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "shareId",
    ///    "txSerialize"
    ///  ],
    ///  "properties": {
    ///    "shareId": {
    ///      "description": "DTO.RED_PACKET.SHARE_ID",
    ///      "examples": [
    ///        "123456"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "txSerialize": {
    ///      "description": "DTO.RED_PACKET.SERIALIZED_TX",
    ///      "examples": [
    ///        "AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAEDRgYGpQEDAQIABQcICQoLDA0ODwAAAAAAAAAAAAAQERITFBUWFxgZGhscHR4fAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA="
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct CreateRedPacketReply {
        ///DTO.RED_PACKET.SHARE_ID
        #[serde(rename = "shareId")]
        pub share_id: ::std::string::String,
        ///DTO.RED_PACKET.SERIALIZED_TX
        #[serde(rename = "txSerialize")]
        pub tx_serialize: ::std::string::String,
    }
    impl ::std::convert::From<&CreateRedPacketReply> for CreateRedPacketReply {
        fn from(value: &CreateRedPacketReply) -> Self {
            value.clone()
        }
    }
    impl CreateRedPacketReply {
        pub fn builder() -> builder::CreateRedPacketReply {
            Default::default()
        }
    }
    ///`CreateTokenInput`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "dex",
    ///    "name",
    ///    "symbol",
    ///    "userAddress"
    ///  ],
    ///  "properties": {
    ///    "dex": {
    ///      "description": "DTO.DEX.IDENTIFIER",
    ///      "examples": [
    ///        "raydium"
    ///      ],
    ///      "type": "string",
    ///      "enum": [
    ///        "raydium",
    ///        "pumpfun",
    ///        "moonshot",
    ///        "candy",
    ///        "launchpad"
    ///      ]
    ///    },
    ///    "extra": {
    ///      "description": "DTO.DEX.MINT.EXTRA",
    ///      "examples": [
    ///        {
    ///          "buyAmount": 0,
    ///          "cliffPeriod": 0,
    ///          "decimals": 6,
    ///          "migrateType": "amm",
    ///          "shareFeeRate": 1000,
    ///          "shareFeeReceiver": "oQPnhXAbLbMuKHESaGrbXT17CyvWCpLyERSJA9HCYd7",
    ///          "slippage": 100,
    ///          "supply": 1000000000000000,
    ///          "totalFundRaisingB": 85000000000,
    ///          "totalLockedAmount": 0,
    ///          "totalSellA": 793100000000000,
    ///          "unlockPeriod": 0
    ///        }
    ///      ],
    ///      "type": "object"
    ///    },
    ///    "image": {
    ///      "description": "DTO.DEX.MINT.IMAGE",
    ///      "examples": [
    ///        "https://assets.candyproject.com/token/icon.png"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "name": {
    ///      "description": "DTO.DEX.MINT.NAME",
    ///      "examples": [
    ///        "Candy Token"
    ///      ],
    ///      "type": "string",
    ///      "maxLength": 32,
    ///      "minLength": 1
    ///    },
    ///    "priorityFee": {
    ///      "description": "DTO.DEX.BASE.PRIORITY_FEE",
    ///      "examples": [
    ///        "1000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "symbol": {
    ///      "description": "DTO.DEX.MINT.SYMBOL",
    ///      "examples": [
    ///        "CANDY"
    ///      ],
    ///      "type": "string",
    ///      "maxLength": 10,
    ///      "minLength": 1
    ///    },
    ///    "uri": {
    ///      "description": "DTO.DEX.MINT.URI",
    ///      "examples": [
    ///        "https://assets.candyproject.com/token/icon.png"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "userAddress": {
    ///      "description": "DTO.DEX.WALLET",
    ///      "examples": [
    ///        "oQPnhXAbLbMuKHESaGrbXT17CyvWCpLyERSJA9HCYd7"
    ///      ],
    ///      "type": "string",
    ///      "maxLength": 64,
    ///      "minLength": 8
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct CreateTokenInput {
        ///DTO.DEX.IDENTIFIER
        pub dex: CreateTokenInputDex,
        ///DTO.DEX.MINT.EXTRA
        #[serde(default, skip_serializing_if = "::serde_json::Map::is_empty")]
        pub extra: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
        ///DTO.DEX.MINT.IMAGE
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub image: ::std::option::Option<::std::string::String>,
        ///DTO.DEX.MINT.NAME
        pub name: CreateTokenInputName,
        ///DTO.DEX.BASE.PRIORITY_FEE
        #[serde(
            rename = "priorityFee",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub priority_fee: ::std::option::Option<::std::string::String>,
        ///DTO.DEX.MINT.SYMBOL
        pub symbol: CreateTokenInputSymbol,
        ///DTO.DEX.MINT.URI
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub uri: ::std::option::Option<::std::string::String>,
        ///DTO.DEX.WALLET
        #[serde(rename = "userAddress")]
        pub user_address: CreateTokenInputUserAddress,
    }
    impl ::std::convert::From<&CreateTokenInput> for CreateTokenInput {
        fn from(value: &CreateTokenInput) -> Self {
            value.clone()
        }
    }
    impl CreateTokenInput {
        pub fn builder() -> builder::CreateTokenInput {
            Default::default()
        }
    }
    ///DTO.DEX.IDENTIFIER
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "DTO.DEX.IDENTIFIER",
    ///  "examples": [
    ///    "raydium"
    ///  ],
    ///  "type": "string",
    ///  "enum": [
    ///    "raydium",
    ///    "pumpfun",
    ///    "moonshot",
    ///    "candy",
    ///    "launchpad"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum CreateTokenInputDex {
        #[serde(rename = "raydium")]
        Raydium,
        #[serde(rename = "pumpfun")]
        Pumpfun,
        #[serde(rename = "moonshot")]
        Moonshot,
        #[serde(rename = "candy")]
        Candy,
        #[serde(rename = "launchpad")]
        Launchpad,
    }
    impl ::std::convert::From<&Self> for CreateTokenInputDex {
        fn from(value: &CreateTokenInputDex) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for CreateTokenInputDex {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::Raydium => f.write_str("raydium"),
                Self::Pumpfun => f.write_str("pumpfun"),
                Self::Moonshot => f.write_str("moonshot"),
                Self::Candy => f.write_str("candy"),
                Self::Launchpad => f.write_str("launchpad"),
            }
        }
    }
    impl ::std::str::FromStr for CreateTokenInputDex {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "raydium" => Ok(Self::Raydium),
                "pumpfun" => Ok(Self::Pumpfun),
                "moonshot" => Ok(Self::Moonshot),
                "candy" => Ok(Self::Candy),
                "launchpad" => Ok(Self::Launchpad),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for CreateTokenInputDex {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String> for CreateTokenInputDex {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for CreateTokenInputDex {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    ///DTO.DEX.MINT.NAME
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "DTO.DEX.MINT.NAME",
    ///  "examples": [
    ///    "Candy Token"
    ///  ],
    ///  "type": "string",
    ///  "maxLength": 32,
    ///  "minLength": 1
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
    #[serde(transparent)]
    pub struct CreateTokenInputName(::std::string::String);
    impl ::std::ops::Deref for CreateTokenInputName {
        type Target = ::std::string::String;
        fn deref(&self) -> &::std::string::String {
            &self.0
        }
    }
    impl ::std::convert::From<CreateTokenInputName> for ::std::string::String {
        fn from(value: CreateTokenInputName) -> Self {
            value.0
        }
    }
    impl ::std::convert::From<&CreateTokenInputName> for CreateTokenInputName {
        fn from(value: &CreateTokenInputName) -> Self {
            value.clone()
        }
    }
    impl ::std::str::FromStr for CreateTokenInputName {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            if value.chars().count() > 32usize {
                return Err("longer than 32 characters".into());
            }
            if value.chars().count() < 1usize {
                return Err("shorter than 1 characters".into());
            }
            Ok(Self(value.to_string()))
        }
    }
    impl ::std::convert::TryFrom<&str> for CreateTokenInputName {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String> for CreateTokenInputName {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for CreateTokenInputName {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl<'de> ::serde::Deserialize<'de> for CreateTokenInputName {
        fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
        where
            D: ::serde::Deserializer<'de>,
        {
            ::std::string::String::deserialize(deserializer)?
                .parse()
                .map_err(|e: self::error::ConversionError| {
                    <D::Error as ::serde::de::Error>::custom(e.to_string())
                })
        }
    }
    ///DTO.DEX.MINT.SYMBOL
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "DTO.DEX.MINT.SYMBOL",
    ///  "examples": [
    ///    "CANDY"
    ///  ],
    ///  "type": "string",
    ///  "maxLength": 10,
    ///  "minLength": 1
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
    #[serde(transparent)]
    pub struct CreateTokenInputSymbol(::std::string::String);
    impl ::std::ops::Deref for CreateTokenInputSymbol {
        type Target = ::std::string::String;
        fn deref(&self) -> &::std::string::String {
            &self.0
        }
    }
    impl ::std::convert::From<CreateTokenInputSymbol> for ::std::string::String {
        fn from(value: CreateTokenInputSymbol) -> Self {
            value.0
        }
    }
    impl ::std::convert::From<&CreateTokenInputSymbol> for CreateTokenInputSymbol {
        fn from(value: &CreateTokenInputSymbol) -> Self {
            value.clone()
        }
    }
    impl ::std::str::FromStr for CreateTokenInputSymbol {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            if value.chars().count() > 10usize {
                return Err("longer than 10 characters".into());
            }
            if value.chars().count() < 1usize {
                return Err("shorter than 1 characters".into());
            }
            Ok(Self(value.to_string()))
        }
    }
    impl ::std::convert::TryFrom<&str> for CreateTokenInputSymbol {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String> for CreateTokenInputSymbol {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for CreateTokenInputSymbol {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl<'de> ::serde::Deserialize<'de> for CreateTokenInputSymbol {
        fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
        where
            D: ::serde::Deserializer<'de>,
        {
            ::std::string::String::deserialize(deserializer)?
                .parse()
                .map_err(|e: self::error::ConversionError| {
                    <D::Error as ::serde::de::Error>::custom(e.to_string())
                })
        }
    }
    ///DTO.DEX.WALLET
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "DTO.DEX.WALLET",
    ///  "examples": [
    ///    "oQPnhXAbLbMuKHESaGrbXT17CyvWCpLyERSJA9HCYd7"
    ///  ],
    ///  "type": "string",
    ///  "maxLength": 64,
    ///  "minLength": 8
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
    #[serde(transparent)]
    pub struct CreateTokenInputUserAddress(::std::string::String);
    impl ::std::ops::Deref for CreateTokenInputUserAddress {
        type Target = ::std::string::String;
        fn deref(&self) -> &::std::string::String {
            &self.0
        }
    }
    impl ::std::convert::From<CreateTokenInputUserAddress> for ::std::string::String {
        fn from(value: CreateTokenInputUserAddress) -> Self {
            value.0
        }
    }
    impl ::std::convert::From<&CreateTokenInputUserAddress>
    for CreateTokenInputUserAddress {
        fn from(value: &CreateTokenInputUserAddress) -> Self {
            value.clone()
        }
    }
    impl ::std::str::FromStr for CreateTokenInputUserAddress {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            if value.chars().count() > 64usize {
                return Err("longer than 64 characters".into());
            }
            if value.chars().count() < 8usize {
                return Err("shorter than 8 characters".into());
            }
            Ok(Self(value.to_string()))
        }
    }
    impl ::std::convert::TryFrom<&str> for CreateTokenInputUserAddress {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String>
    for CreateTokenInputUserAddress {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for CreateTokenInputUserAddress {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl<'de> ::serde::Deserialize<'de> for CreateTokenInputUserAddress {
        fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
        where
            D: ::serde::Deserializer<'de>,
        {
            ::std::string::String::deserialize(deserializer)?
                .parse()
                .map_err(|e: self::error::ConversionError| {
                    <D::Error as ::serde::de::Error>::custom(e.to_string())
                })
        }
    }
    ///`CreateTokenReply`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "mintAddress",
    ///    "serializedTx"
    ///  ],
    ///  "properties": {
    ///    "mintAddress": {
    ///      "description": "DTO.DEX.CREATE_TOKEN.MINT_ADDRESS",
    ///      "examples": [
    ///        "So11111111111111111111111111111111111111112"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "serializedTx": {
    ///      "description": "DTO.DEX.CREATE_TOKEN.SERIALIZED_TX",
    ///      "examples": [
    ///        "AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAEDRgYGpQEDAQIABQcICQoLDA0ODwAAAAAAAAAAAAAQERITFBUWFxgZGhscHR4fAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA="
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct CreateTokenReply {
        ///DTO.DEX.CREATE_TOKEN.MINT_ADDRESS
        #[serde(rename = "mintAddress")]
        pub mint_address: ::std::string::String,
        ///DTO.DEX.CREATE_TOKEN.SERIALIZED_TX
        #[serde(rename = "serializedTx")]
        pub serialized_tx: ::std::string::String,
    }
    impl ::std::convert::From<&CreateTokenReply> for CreateTokenReply {
        fn from(value: &CreateTokenReply) -> Self {
            value.clone()
        }
    }
    impl CreateTokenReply {
        pub fn builder() -> builder::CreateTokenReply {
            Default::default()
        }
    }
    ///`DevTokenDto`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "address",
    ///    "marketData",
    ///    "metadata",
    ///    "stats"
    ///  ],
    ///  "properties": {
    ///    "address": {
    ///      "description": "DTO.DEV_TOKEN.ADDRESS",
    ///      "type": "string"
    ///    },
    ///    "marketData": {
    ///      "description": "DTO.DEV_TOKEN.MARKET_DATA",
    ///      "allOf": [
    ///        {
    ///          "$ref": "#/components/schemas/TokenMarketData"
    ///        }
    ///      ]
    ///    },
    ///    "metadata": {
    ///      "description": "DTO.DEV_TOKEN.METADATA",
    ///      "allOf": [
    ///        {
    ///          "$ref": "#/components/schemas/TokenMetadata"
    ///        }
    ///      ]
    ///    },
    ///    "stats": {
    ///      "description": "DTO.DEV_TOKEN.STATS",
    ///      "allOf": [
    ///        {
    ///          "$ref": "#/components/schemas/TokenStat"
    ///        }
    ///      ]
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct DevTokenDto {
        ///DTO.DEV_TOKEN.ADDRESS
        pub address: ::std::string::String,
        ///DTO.DEV_TOKEN.MARKET_DATA
        #[serde(rename = "marketData")]
        pub market_data: TokenMarketData,
        ///DTO.DEV_TOKEN.METADATA
        pub metadata: TokenMetadata,
        ///DTO.DEV_TOKEN.STATS
        pub stats: TokenStat,
    }
    impl ::std::convert::From<&DevTokenDto> for DevTokenDto {
        fn from(value: &DevTokenDto) -> Self {
            value.clone()
        }
    }
    impl DevTokenDto {
        pub fn builder() -> builder::DevTokenDto {
            Default::default()
        }
    }
    ///`DexDto`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "chain"
    ///  ],
    ///  "properties": {
    ///    "chain": {
    ///      "description": "DTO.DEX.CHAIN",
    ///      "examples": [
    ///        "sol"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "image": {
    ///      "description": "DTO.DEX.IMAGE",
    ///      "examples": [
    ///        "https://ipfs.io/ipfs/bafkreid7667676767676767676767676767676767676767676767676767676767676767"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "programAddress": {
    ///      "description": "DTO.DEX.PROGRAM_ADDRESS",
    ///      "examples": [
    ///        "whirLbMiicVdio4qvUfM5KAg6Ct8VwpYzGff3uctyCc"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "protocolFamily": {
    ///      "description": "DTO.DEX.PROTOCOL_FAMILY",
    ///      "examples": [
    ///        "OrcaWhirpool"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct DexDto {
        ///DTO.DEX.CHAIN
        pub chain: ::std::string::String,
        ///DTO.DEX.IMAGE
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub image: ::std::option::Option<::std::string::String>,
        ///DTO.DEX.PROGRAM_ADDRESS
        #[serde(
            rename = "programAddress",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub program_address: ::std::option::Option<::std::string::String>,
        ///DTO.DEX.PROTOCOL_FAMILY
        #[serde(
            rename = "protocolFamily",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub protocol_family: ::std::option::Option<::std::string::String>,
    }
    impl ::std::convert::From<&DexDto> for DexDto {
        fn from(value: &DexDto) -> Self {
            value.clone()
        }
    }
    impl DexDto {
        pub fn builder() -> builder::DexDto {
            Default::default()
        }
    }
    ///`DexPage`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "data"
    ///  ],
    ///  "properties": {
    ///    "data": {
    ///      "description": "DTO.DEX.PAGE.DATA",
    ///      "type": "array",
    ///      "items": {
    ///        "$ref": "#/components/schemas/DexDTO"
    ///      }
    ///    },
    ///    "endCursor": {
    ///      "description": "DTO.PAGE.END_CURSOR",
    ///      "type": "string"
    ///    },
    ///    "hasNext": {
    ///      "description": "DTO.PAGE.HAS_NEXT",
    ///      "default": false,
    ///      "type": "boolean"
    ///    },
    ///    "hasPrev": {
    ///      "description": "DTO.PAGE.HAS_PREV",
    ///      "default": false,
    ///      "type": "boolean"
    ///    },
    ///    "startCursor": {
    ///      "description": "DTO.PAGE.START_CURSOR",
    ///      "type": "string"
    ///    },
    ///    "total": {
    ///      "description": "DTO.PAGE.TOTAL",
    ///      "default": 0,
    ///      "type": "integer",
    ///      "format": "int64"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct DexPage {
        ///DTO.DEX.PAGE.DATA
        pub data: ::std::vec::Vec<DexDto>,
        ///DTO.PAGE.END_CURSOR
        #[serde(
            rename = "endCursor",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub end_cursor: ::std::option::Option<::std::string::String>,
        ///DTO.PAGE.HAS_NEXT
        #[serde(rename = "hasNext", default)]
        pub has_next: bool,
        ///DTO.PAGE.HAS_PREV
        #[serde(rename = "hasPrev", default)]
        pub has_prev: bool,
        ///DTO.PAGE.START_CURSOR
        #[serde(
            rename = "startCursor",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub start_cursor: ::std::option::Option<::std::string::String>,
        ///DTO.PAGE.TOTAL
        #[serde(default)]
        pub total: i64,
    }
    impl ::std::convert::From<&DexPage> for DexPage {
        fn from(value: &DexPage) -> Self {
            value.clone()
        }
    }
    impl DexPage {
        pub fn builder() -> builder::DexPage {
            Default::default()
        }
    }
    ///`DexPoolDto`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "chain",
    ///    "poolAddress",
    ///    "tokenAAddress",
    ///    "tokenBAddress"
    ///  ],
    ///  "properties": {
    ///    "chain": {
    ///      "description": "DTO.DEX.CHAIN",
    ///      "examples": [
    ///        "sol"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "createdBlockTimestamp": {
    ///      "description": "DTO.DEXPOOL.CREATED_BLOCK_TIMESTAMP",
    ///      "examples": [
    ///        "2024-01-15T10:30:00Z"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "feeRate": {
    ///      "description": "DTO.DEXPOOL.FEE_RATE",
    ///      "examples": [
    ///        "0.003"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "image": {
    ///      "description": "DTO.DEX.IMAGE",
    ///      "examples": [
    ///        "https://ipfs.io/ipfs/bafkreid7667676767676767676767676767676767676767676767676767676767676767"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "liquidityModel": {
    ///      "description": "DTO.DEXPOOL.LIQUIDITY_MODEL",
    ///      "examples": [
    ///        1
    ///      ],
    ///      "type": "number",
    ///      "enum": [
    ///        0.0,
    ///        1.0,
    ///        2.0,
    ///        3.0,
    ///        4.0
    ///      ]
    ///    },
    ///    "poolAddress": {
    ///      "description": "DTO.DEXPOOL.POOL_ADDRESS",
    ///      "examples": [
    ///        "58oQChx4yWmvKdwLLZzBi4ChoCc2fqCUWBkwMihLYQo2"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "programAddress": {
    ///      "description": "DTO.DEX.PROGRAM_ADDRESS",
    ///      "examples": [
    ///        "whirLbMiicVdio4qvUfM5KAg6Ct8VwpYzGff3uctyCc"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "protocolFamily": {
    ///      "description": "DTO.DEX.PROTOCOL_FAMILY",
    ///      "examples": [
    ///        "OrcaWhirpool"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "protocolName": {
    ///      "description": "DTO.DEXPOOL.PROTOCOL_NAME",
    ///      "examples": [
    ///        "OrcaWhirpool AMM V2"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "tickSpacing": {
    ///      "description": "DTO.DEXPOOL.TICK_SPACING",
    ///      "examples": [
    ///        64
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "tokenAAddress": {
    ///      "description": "DTO.DEXPOOL.TOKEN_A",
    ///      "examples": [
    ///        "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "tokenALiquidity": {
    ///      "description": "DTO.DEXPOOL.TOKEN_A_LIQUIDITY",
    ///      "allOf": [
    ///        {
    ///          "$ref": "#/components/schemas/DexPoolTokenLiquidity"
    ///        }
    ///      ]
    ///    },
    ///    "tokenBAddress": {
    ///      "description": "DTO.DEXPOOL.TOKEN_B",
    ///      "examples": [
    ///        "Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "tokenBLiquidity": {
    ///      "description": "DTO.DEXPOOL.TOKEN_B_LIQUIDITY",
    ///      "allOf": [
    ///        {
    ///          "$ref": "#/components/schemas/DexPoolTokenLiquidity"
    ///        }
    ///      ]
    ///    },
    ///    "tokenCount": {
    ///      "description": "DTO.DEXPOOL.TOKEN_COUNT",
    ///      "examples": [
    ///        2
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "tvlInSol": {
    ///      "description": "DTO.DEXPOOL.TVL_SOL",
    ///      "examples": [
    ///        "1000000.45"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "tvlInUsd": {
    ///      "description": "DTO.DEXPOOL.TVL_USD",
    ///      "examples": [
    ///        "1000000.45"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "type": {
    ///      "description": "DTO.DEXPOOL.TYPE",
    ///      "examples": [
    ///        1
    ///      ],
    ///      "type": "number",
    ///      "enum": [
    ///        0.0,
    ///        1.0,
    ///        2.0,
    ///        3.0,
    ///        4.0
    ///      ]
    ///    },
    ///    "version": {
    ///      "description": "DTO.DEXPOOL.VERSION",
    ///      "examples": [
    ///        2
    ///      ],
    ///      "type": "number",
    ///      "enum": [
    ///        0.0,
    ///        1.0,
    ///        2.0,
    ///        3.0
    ///      ]
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct DexPoolDto {
        ///DTO.DEX.CHAIN
        pub chain: ::std::string::String,
        ///DTO.DEXPOOL.CREATED_BLOCK_TIMESTAMP
        #[serde(
            rename = "createdBlockTimestamp",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub created_block_timestamp: ::std::option::Option<::std::string::String>,
        ///DTO.DEXPOOL.FEE_RATE
        #[serde(
            rename = "feeRate",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub fee_rate: ::std::option::Option<::std::string::String>,
        ///DTO.DEX.IMAGE
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub image: ::std::option::Option<::std::string::String>,
        #[serde(
            rename = "liquidityModel",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub liquidity_model: ::std::option::Option<DexPoolDtoLiquidityModel>,
        ///DTO.DEXPOOL.POOL_ADDRESS
        #[serde(rename = "poolAddress")]
        pub pool_address: ::std::string::String,
        ///DTO.DEX.PROGRAM_ADDRESS
        #[serde(
            rename = "programAddress",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub program_address: ::std::option::Option<::std::string::String>,
        ///DTO.DEX.PROTOCOL_FAMILY
        #[serde(
            rename = "protocolFamily",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub protocol_family: ::std::option::Option<::std::string::String>,
        ///DTO.DEXPOOL.PROTOCOL_NAME
        #[serde(
            rename = "protocolName",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub protocol_name: ::std::option::Option<::std::string::String>,
        ///DTO.DEXPOOL.TICK_SPACING
        #[serde(
            rename = "tickSpacing",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub tick_spacing: ::std::option::Option<i64>,
        ///DTO.DEXPOOL.TOKEN_A
        #[serde(rename = "tokenAAddress")]
        pub token_a_address: ::std::string::String,
        ///DTO.DEXPOOL.TOKEN_A_LIQUIDITY
        #[serde(
            rename = "tokenALiquidity",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub token_a_liquidity: ::std::option::Option<DexPoolTokenLiquidity>,
        ///DTO.DEXPOOL.TOKEN_B
        #[serde(rename = "tokenBAddress")]
        pub token_b_address: ::std::string::String,
        ///DTO.DEXPOOL.TOKEN_B_LIQUIDITY
        #[serde(
            rename = "tokenBLiquidity",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub token_b_liquidity: ::std::option::Option<DexPoolTokenLiquidity>,
        ///DTO.DEXPOOL.TOKEN_COUNT
        #[serde(
            rename = "tokenCount",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub token_count: ::std::option::Option<i64>,
        ///DTO.DEXPOOL.TVL_SOL
        #[serde(
            rename = "tvlInSol",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub tvl_in_sol: ::std::option::Option<::std::string::String>,
        ///DTO.DEXPOOL.TVL_USD
        #[serde(
            rename = "tvlInUsd",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub tvl_in_usd: ::std::option::Option<::std::string::String>,
        #[serde(
            rename = "type",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub type_: ::std::option::Option<DexPoolDtoType>,
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub version: ::std::option::Option<DexPoolDtoVersion>,
    }
    impl ::std::convert::From<&DexPoolDto> for DexPoolDto {
        fn from(value: &DexPoolDto) -> Self {
            value.clone()
        }
    }
    impl DexPoolDto {
        pub fn builder() -> builder::DexPoolDto {
            Default::default()
        }
    }
    ///`DexPoolDtoLiquidityModel`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "DTO.DEXPOOL.LIQUIDITY_MODEL",
    ///  "examples": [
    ///    1
    ///  ],
    ///  "type": "number",
    ///  "enum": [
    ///    0.0,
    ///    1.0,
    ///    2.0,
    ///    3.0,
    ///    4.0
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Serialize, Clone, Debug)]
    #[serde(transparent)]
    pub struct DexPoolDtoLiquidityModel(f64);
    impl ::std::ops::Deref for DexPoolDtoLiquidityModel {
        type Target = f64;
        fn deref(&self) -> &f64 {
            &self.0
        }
    }
    impl ::std::convert::From<DexPoolDtoLiquidityModel> for f64 {
        fn from(value: DexPoolDtoLiquidityModel) -> Self {
            value.0
        }
    }
    impl ::std::convert::From<&DexPoolDtoLiquidityModel> for DexPoolDtoLiquidityModel {
        fn from(value: &DexPoolDtoLiquidityModel) -> Self {
            value.clone()
        }
    }
    impl ::std::convert::TryFrom<f64> for DexPoolDtoLiquidityModel {
        type Error = self::error::ConversionError;
        fn try_from(
            value: f64,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            if ![0.0_f64, 1.0_f64, 2.0_f64, 3.0_f64, 4.0_f64].contains(&value) {
                Err("invalid value".into())
            } else {
                Ok(Self(value))
            }
        }
    }
    impl<'de> ::serde::Deserialize<'de> for DexPoolDtoLiquidityModel {
        fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
        where
            D: ::serde::Deserializer<'de>,
        {
            Self::try_from(<f64>::deserialize(deserializer)?)
                .map_err(|e| { <D::Error as ::serde::de::Error>::custom(e.to_string()) })
        }
    }
    ///`DexPoolDtoType`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "DTO.DEXPOOL.TYPE",
    ///  "examples": [
    ///    1
    ///  ],
    ///  "type": "number",
    ///  "enum": [
    ///    0.0,
    ///    1.0,
    ///    2.0,
    ///    3.0,
    ///    4.0
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Serialize, Clone, Debug)]
    #[serde(transparent)]
    pub struct DexPoolDtoType(f64);
    impl ::std::ops::Deref for DexPoolDtoType {
        type Target = f64;
        fn deref(&self) -> &f64 {
            &self.0
        }
    }
    impl ::std::convert::From<DexPoolDtoType> for f64 {
        fn from(value: DexPoolDtoType) -> Self {
            value.0
        }
    }
    impl ::std::convert::From<&DexPoolDtoType> for DexPoolDtoType {
        fn from(value: &DexPoolDtoType) -> Self {
            value.clone()
        }
    }
    impl ::std::convert::TryFrom<f64> for DexPoolDtoType {
        type Error = self::error::ConversionError;
        fn try_from(
            value: f64,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            if ![0.0_f64, 1.0_f64, 2.0_f64, 3.0_f64, 4.0_f64].contains(&value) {
                Err("invalid value".into())
            } else {
                Ok(Self(value))
            }
        }
    }
    impl<'de> ::serde::Deserialize<'de> for DexPoolDtoType {
        fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
        where
            D: ::serde::Deserializer<'de>,
        {
            Self::try_from(<f64>::deserialize(deserializer)?)
                .map_err(|e| { <D::Error as ::serde::de::Error>::custom(e.to_string()) })
        }
    }
    ///`DexPoolDtoVersion`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "DTO.DEXPOOL.VERSION",
    ///  "examples": [
    ///    2
    ///  ],
    ///  "type": "number",
    ///  "enum": [
    ///    0.0,
    ///    1.0,
    ///    2.0,
    ///    3.0
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Serialize, Clone, Debug)]
    #[serde(transparent)]
    pub struct DexPoolDtoVersion(f64);
    impl ::std::ops::Deref for DexPoolDtoVersion {
        type Target = f64;
        fn deref(&self) -> &f64 {
            &self.0
        }
    }
    impl ::std::convert::From<DexPoolDtoVersion> for f64 {
        fn from(value: DexPoolDtoVersion) -> Self {
            value.0
        }
    }
    impl ::std::convert::From<&DexPoolDtoVersion> for DexPoolDtoVersion {
        fn from(value: &DexPoolDtoVersion) -> Self {
            value.clone()
        }
    }
    impl ::std::convert::TryFrom<f64> for DexPoolDtoVersion {
        type Error = self::error::ConversionError;
        fn try_from(
            value: f64,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            if ![0.0_f64, 1.0_f64, 2.0_f64, 3.0_f64].contains(&value) {
                Err("invalid value".into())
            } else {
                Ok(Self(value))
            }
        }
    }
    impl<'de> ::serde::Deserialize<'de> for DexPoolDtoVersion {
        fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
        where
            D: ::serde::Deserializer<'de>,
        {
            Self::try_from(<f64>::deserialize(deserializer)?)
                .map_err(|e| { <D::Error as ::serde::de::Error>::custom(e.to_string()) })
        }
    }
    ///`DexPoolPage`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "data"
    ///  ],
    ///  "properties": {
    ///    "data": {
    ///      "description": "DTO.DEXPOOL.PAGE.DATA",
    ///      "type": "array",
    ///      "items": {
    ///        "$ref": "#/components/schemas/DexPoolDTO"
    ///      }
    ///    },
    ///    "endCursor": {
    ///      "description": "DTO.PAGE.END_CURSOR",
    ///      "type": "string"
    ///    },
    ///    "hasNext": {
    ///      "description": "DTO.PAGE.HAS_NEXT",
    ///      "default": false,
    ///      "type": "boolean"
    ///    },
    ///    "hasPrev": {
    ///      "description": "DTO.PAGE.HAS_PREV",
    ///      "default": false,
    ///      "type": "boolean"
    ///    },
    ///    "startCursor": {
    ///      "description": "DTO.PAGE.START_CURSOR",
    ///      "type": "string"
    ///    },
    ///    "total": {
    ///      "description": "DTO.PAGE.TOTAL",
    ///      "default": 0,
    ///      "type": "integer",
    ///      "format": "int64"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct DexPoolPage {
        ///DTO.DEXPOOL.PAGE.DATA
        pub data: ::std::vec::Vec<DexPoolDto>,
        ///DTO.PAGE.END_CURSOR
        #[serde(
            rename = "endCursor",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub end_cursor: ::std::option::Option<::std::string::String>,
        ///DTO.PAGE.HAS_NEXT
        #[serde(rename = "hasNext", default)]
        pub has_next: bool,
        ///DTO.PAGE.HAS_PREV
        #[serde(rename = "hasPrev", default)]
        pub has_prev: bool,
        ///DTO.PAGE.START_CURSOR
        #[serde(
            rename = "startCursor",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub start_cursor: ::std::option::Option<::std::string::String>,
        ///DTO.PAGE.TOTAL
        #[serde(default)]
        pub total: i64,
    }
    impl ::std::convert::From<&DexPoolPage> for DexPoolPage {
        fn from(value: &DexPoolPage) -> Self {
            value.clone()
        }
    }
    impl DexPoolPage {
        pub fn builder() -> builder::DexPoolPage {
            Default::default()
        }
    }
    ///`DexPoolSnapshotDto`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "blockHeight",
    ///    "blockTimestamp",
    ///    "poolAddress",
    ///    "snapshotTime",
    ///    "tokenA",
    ///    "tokenB",
    ///    "tvlInNative",
    ///    "tvlInUsd"
    ///  ],
    ///  "properties": {
    ///    "blockHeight": {
    ///      "description": "DTO.DEXPOOL.SNAPSHOT.BLOCK_HEIGHT",
    ///      "examples": [
    ///        123456789
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "blockSlot": {
    ///      "description": "DTO.DEXPOOL.SNAPSHOT.BLOCK_SLOT",
    ///      "examples": [
    ///        123456789
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "blockTimestamp": {
    ///      "description": "DTO.DEXPOOL.SNAPSHOT.BLOCK_TIMESTAMP",
    ///      "examples": [
    ///        1705312800000
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "poolAddress": {
    ///      "description": "DTO.DEXPOOL.POOL_ADDRESS",
    ///      "examples": [
    ///        "58oQChx4yWmvKdwLLZzBi4ChoCc2fqCUWBkwMihLYQo2"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "snapshotTime": {
    ///      "description": "DTO.DEXPOOL.SNAPSHOT.SNAPSHOT_TIME",
    ///      "examples": [
    ///        1705312800000
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "tokenA": {
    ///      "description": "DTO.DEXPOOL.SNAPSHOT.TOKEN_A",
    ///      "allOf": [
    ///        {
    ///          "$ref": "#/components/schemas/DexPoolTokenSnapshotDTO"
    ///        }
    ///      ]
    ///    },
    ///    "tokenB": {
    ///      "description": "DTO.DEXPOOL.SNAPSHOT.TOKEN_B",
    ///      "allOf": [
    ///        {
    ///          "$ref": "#/components/schemas/DexPoolTokenSnapshotDTO"
    ///        }
    ///      ]
    ///    },
    ///    "tvlInNative": {
    ///      "description": "DTO.DEXPOOL.TVL_SOL",
    ///      "examples": [
    ///        "5000.123"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "tvlInUsd": {
    ///      "description": "DTO.DEXPOOL.TVL_USD",
    ///      "examples": [
    ///        "1000000.45"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct DexPoolSnapshotDto {
        ///DTO.DEXPOOL.SNAPSHOT.BLOCK_HEIGHT
        #[serde(rename = "blockHeight")]
        pub block_height: i64,
        ///DTO.DEXPOOL.SNAPSHOT.BLOCK_SLOT
        #[serde(
            rename = "blockSlot",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub block_slot: ::std::option::Option<i64>,
        ///DTO.DEXPOOL.SNAPSHOT.BLOCK_TIMESTAMP
        #[serde(rename = "blockTimestamp")]
        pub block_timestamp: i64,
        ///DTO.DEXPOOL.POOL_ADDRESS
        #[serde(rename = "poolAddress")]
        pub pool_address: ::std::string::String,
        ///DTO.DEXPOOL.SNAPSHOT.SNAPSHOT_TIME
        #[serde(rename = "snapshotTime")]
        pub snapshot_time: i64,
        ///DTO.DEXPOOL.SNAPSHOT.TOKEN_A
        #[serde(rename = "tokenA")]
        pub token_a: DexPoolTokenSnapshotDto,
        ///DTO.DEXPOOL.SNAPSHOT.TOKEN_B
        #[serde(rename = "tokenB")]
        pub token_b: DexPoolTokenSnapshotDto,
        ///DTO.DEXPOOL.TVL_SOL
        #[serde(rename = "tvlInNative")]
        pub tvl_in_native: ::std::string::String,
        ///DTO.DEXPOOL.TVL_USD
        #[serde(rename = "tvlInUsd")]
        pub tvl_in_usd: ::std::string::String,
    }
    impl ::std::convert::From<&DexPoolSnapshotDto> for DexPoolSnapshotDto {
        fn from(value: &DexPoolSnapshotDto) -> Self {
            value.clone()
        }
    }
    impl DexPoolSnapshotDto {
        pub fn builder() -> builder::DexPoolSnapshotDto {
            Default::default()
        }
    }
    ///`DexPoolSnapshotPage`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "data",
    ///    "hasNext",
    ///    "hasPrev"
    ///  ],
    ///  "properties": {
    ///    "data": {
    ///      "description": "DTO.PAGE.DATA",
    ///      "type": "array",
    ///      "items": {
    ///        "$ref": "#/components/schemas/DexPoolSnapshotDTO"
    ///      }
    ///    },
    ///    "endCursor": {
    ///      "description": "DTO.PAGE.END_CURSOR",
    ///      "type": "string"
    ///    },
    ///    "hasNext": {
    ///      "description": "DTO.PAGE.HAS_NEXT",
    ///      "default": false,
    ///      "type": "boolean"
    ///    },
    ///    "hasPrev": {
    ///      "description": "DTO.PAGE.HAS_PREV",
    ///      "default": false,
    ///      "type": "boolean"
    ///    },
    ///    "startCursor": {
    ///      "description": "DTO.PAGE.START_CURSOR",
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct DexPoolSnapshotPage {
        ///DTO.PAGE.DATA
        pub data: ::std::vec::Vec<DexPoolSnapshotDto>,
        ///DTO.PAGE.END_CURSOR
        #[serde(
            rename = "endCursor",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub end_cursor: ::std::option::Option<::std::string::String>,
        ///DTO.PAGE.HAS_NEXT
        #[serde(rename = "hasNext")]
        pub has_next: bool,
        ///DTO.PAGE.HAS_PREV
        #[serde(rename = "hasPrev")]
        pub has_prev: bool,
        ///DTO.PAGE.START_CURSOR
        #[serde(
            rename = "startCursor",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub start_cursor: ::std::option::Option<::std::string::String>,
    }
    impl ::std::convert::From<&DexPoolSnapshotPage> for DexPoolSnapshotPage {
        fn from(value: &DexPoolSnapshotPage) -> Self {
            value.clone()
        }
    }
    impl DexPoolSnapshotPage {
        pub fn builder() -> builder::DexPoolSnapshotPage {
            Default::default()
        }
    }
    ///`DexPoolTokenLiquidity`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "amountInNative",
    ///    "amountInUsd",
    ///    "decimals",
    ///    "priceNative",
    ///    "priceUsd",
    ///    "tokenAddress",
    ///    "vaultAmount"
    ///  ],
    ///  "properties": {
    ///    "amountInNative": {
    ///      "description": "DTO.DEXPOOL.AMOUNT_IN_NATIVE",
    ///      "examples": [
    ///        "5000.123"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "amountInUsd": {
    ///      "description": "DTO.DEXPOOL.AMOUNT_IN_USD",
    ///      "examples": [
    ///        "1000000.45"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "decimals": {
    ///      "description": "DTO.DEXPOOL.TOKEN_DECIMALS",
    ///      "examples": [
    ///        6
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "priceNative": {
    ///      "description": "DTO.DEXPOOL.PRICE_NATIVE",
    ///      "examples": [
    ///        "0.005"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "priceUsd": {
    ///      "description": "DTO.DEXPOOL.PRICE_USD",
    ///      "examples": [
    ///        "1.0001"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "tokenAddress": {
    ///      "description": "DTO.DEXPOOL.TOKEN_ADDRESS",
    ///      "examples": [
    ///        "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "vaultAmount": {
    ///      "description": "DTO.DEXPOOL.VAULT_AMOUNT",
    ///      "examples": [
    ///        "1000000000000"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct DexPoolTokenLiquidity {
        ///DTO.DEXPOOL.AMOUNT_IN_NATIVE
        #[serde(rename = "amountInNative")]
        pub amount_in_native: ::std::string::String,
        ///DTO.DEXPOOL.AMOUNT_IN_USD
        #[serde(rename = "amountInUsd")]
        pub amount_in_usd: ::std::string::String,
        ///DTO.DEXPOOL.TOKEN_DECIMALS
        pub decimals: i64,
        ///DTO.DEXPOOL.PRICE_NATIVE
        #[serde(rename = "priceNative")]
        pub price_native: ::std::string::String,
        ///DTO.DEXPOOL.PRICE_USD
        #[serde(rename = "priceUsd")]
        pub price_usd: ::std::string::String,
        ///DTO.DEXPOOL.TOKEN_ADDRESS
        #[serde(rename = "tokenAddress")]
        pub token_address: ::std::string::String,
        ///DTO.DEXPOOL.VAULT_AMOUNT
        #[serde(rename = "vaultAmount")]
        pub vault_amount: ::std::string::String,
    }
    impl ::std::convert::From<&DexPoolTokenLiquidity> for DexPoolTokenLiquidity {
        fn from(value: &DexPoolTokenLiquidity) -> Self {
            value.clone()
        }
    }
    impl DexPoolTokenLiquidity {
        pub fn builder() -> builder::DexPoolTokenLiquidity {
            Default::default()
        }
    }
    ///`DexPoolTokenSnapshotDto`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "amountInNative",
    ///    "amountInUsd",
    ///    "decimals",
    ///    "priceNative",
    ///    "priceUsd",
    ///    "tokenAddress",
    ///    "vaultAmount"
    ///  ],
    ///  "properties": {
    ///    "amountInNative": {
    ///      "description": "DTO.DEXPOOL.AMOUNT_IN_NATIVE",
    ///      "examples": [
    ///        "5000.123"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "amountInUsd": {
    ///      "description": "DTO.DEXPOOL.AMOUNT_IN_USD",
    ///      "examples": [
    ///        "1000000.45"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "decimals": {
    ///      "description": "DTO.DEXPOOL.TOKEN_DECIMALS",
    ///      "examples": [
    ///        6
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "priceNative": {
    ///      "description": "DTO.DEXPOOL.PRICE_NATIVE",
    ///      "examples": [
    ///        "0.005"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "priceUsd": {
    ///      "description": "DTO.DEXPOOL.PRICE_USD",
    ///      "examples": [
    ///        "1.0001"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "tokenAddress": {
    ///      "description": "DTO.DEXPOOL.TOKEN_ADDRESS",
    ///      "examples": [
    ///        "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "vaultAmount": {
    ///      "description": "DTO.DEXPOOL.VAULT_AMOUNT",
    ///      "examples": [
    ///        "1000000000000"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct DexPoolTokenSnapshotDto {
        ///DTO.DEXPOOL.AMOUNT_IN_NATIVE
        #[serde(rename = "amountInNative")]
        pub amount_in_native: ::std::string::String,
        ///DTO.DEXPOOL.AMOUNT_IN_USD
        #[serde(rename = "amountInUsd")]
        pub amount_in_usd: ::std::string::String,
        ///DTO.DEXPOOL.TOKEN_DECIMALS
        pub decimals: i64,
        ///DTO.DEXPOOL.PRICE_NATIVE
        #[serde(rename = "priceNative")]
        pub price_native: ::std::string::String,
        ///DTO.DEXPOOL.PRICE_USD
        #[serde(rename = "priceUsd")]
        pub price_usd: ::std::string::String,
        ///DTO.DEXPOOL.TOKEN_ADDRESS
        #[serde(rename = "tokenAddress")]
        pub token_address: ::std::string::String,
        ///DTO.DEXPOOL.VAULT_AMOUNT
        #[serde(rename = "vaultAmount")]
        pub vault_amount: ::std::string::String,
    }
    impl ::std::convert::From<&DexPoolTokenSnapshotDto> for DexPoolTokenSnapshotDto {
        fn from(value: &DexPoolTokenSnapshotDto) -> Self {
            value.clone()
        }
    }
    impl DexPoolTokenSnapshotDto {
        pub fn builder() -> builder::DexPoolTokenSnapshotDto {
            Default::default()
        }
    }
    ///`DexQuoteResponse`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "properties": {
    ///    "amountOut": {
    ///      "description": "DTO.DEX.QUOTE.AMOUNT_OUT",
    ///      "examples": [
    ///        "1000000000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "currentPrice": {
    ///      "description": "DTO.DEX.QUOTE.CURRENT_PRICE",
    ///      "type": "string"
    ///    },
    ///    "executionPrice": {
    ///      "description": "DTO.DEX.QUOTE.EXECUTION_PRICE",
    ///      "type": "string"
    ///    },
    ///    "fee": {
    ///      "description": "DTO.DEX.QUOTE.FEE",
    ///      "examples": [
    ///        "1000000000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "minAmountOut": {
    ///      "description": "DTO.DEX.QUOTE.MIN_AMOUNT_OUT",
    ///      "type": "string"
    ///    },
    ///    "priceImpact": {
    ///      "description": "DTO.DEX.QUOTE.PRICE_IMPACT",
    ///      "examples": [
    ///        "10.5"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct DexQuoteResponse {
        ///DTO.DEX.QUOTE.AMOUNT_OUT
        #[serde(
            rename = "amountOut",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub amount_out: ::std::option::Option<::std::string::String>,
        ///DTO.DEX.QUOTE.CURRENT_PRICE
        #[serde(
            rename = "currentPrice",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub current_price: ::std::option::Option<::std::string::String>,
        ///DTO.DEX.QUOTE.EXECUTION_PRICE
        #[serde(
            rename = "executionPrice",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub execution_price: ::std::option::Option<::std::string::String>,
        ///DTO.DEX.QUOTE.FEE
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub fee: ::std::option::Option<::std::string::String>,
        ///DTO.DEX.QUOTE.MIN_AMOUNT_OUT
        #[serde(
            rename = "minAmountOut",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub min_amount_out: ::std::option::Option<::std::string::String>,
        ///DTO.DEX.QUOTE.PRICE_IMPACT
        #[serde(
            rename = "priceImpact",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub price_impact: ::std::option::Option<::std::string::String>,
    }
    impl ::std::convert::From<&DexQuoteResponse> for DexQuoteResponse {
        fn from(value: &DexQuoteResponse) -> Self {
            value.clone()
        }
    }
    impl ::std::default::Default for DexQuoteResponse {
        fn default() -> Self {
            Self {
                amount_out: Default::default(),
                current_price: Default::default(),
                execution_price: Default::default(),
                fee: Default::default(),
                min_amount_out: Default::default(),
                price_impact: Default::default(),
            }
        }
    }
    impl DexQuoteResponse {
        pub fn builder() -> builder::DexQuoteResponse {
            Default::default()
        }
    }
    ///`DirectExposureDetail`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "categoryId",
    ///    "name"
    ///  ],
    ///  "properties": {
    ///    "categoryId": {
    ///      "description": "DTO.KYT.DIRECT_EXPOSURE_DETAIL.CATEGORY_ID",
    ///      "examples": [
    ///        17
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "name": {
    ///      "description": "DTO.KYT.DIRECT_EXPOSURE_DETAIL.NAME",
    ///      "examples": [
    ///        "BitPay.com"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct DirectExposureDetail {
        ///DTO.KYT.DIRECT_EXPOSURE_DETAIL.CATEGORY_ID
        #[serde(rename = "categoryId")]
        pub category_id: i64,
        ///DTO.KYT.DIRECT_EXPOSURE_DETAIL.NAME
        pub name: ::std::string::String,
    }
    impl ::std::convert::From<&DirectExposureDetail> for DirectExposureDetail {
        fn from(value: &DirectExposureDetail) -> Self {
            value.clone()
        }
    }
    impl DirectExposureDetail {
        pub fn builder() -> builder::DirectExposureDetail {
            Default::default()
        }
    }
    ///`EndpointListResponse`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "properties": {
    ///    "data": {
    ///      "description": "DTO.ENDPOINT.PAGE.DATA",
    ///      "type": "array",
    ///      "items": {
    ///        "$ref": "#/components/schemas/EndpointResponse"
    ///      }
    ///    },
    ///    "done": {
    ///      "description": "DTO.ENDPOINT.PAGE.DONE",
    ///      "examples": [
    ///        false
    ///      ],
    ///      "type": "boolean"
    ///    },
    ///    "iterator": {
    ///      "description": "DTO.ENDPOINT.PAGE.ITERATOR",
    ///      "examples": [
    ///        "eyJpZCI6MTAwfQ=="
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "prevIterator": {
    ///      "description": "DTO.ENDPOINT.PAGE.PREV_ITERATOR",
    ///      "examples": [
    ///        "eyJpZCI6MTAwfQ=="
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct EndpointListResponse {
        ///DTO.ENDPOINT.PAGE.DATA
        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
        pub data: ::std::vec::Vec<EndpointResponse>,
        ///DTO.ENDPOINT.PAGE.DONE
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub done: ::std::option::Option<bool>,
        ///DTO.ENDPOINT.PAGE.ITERATOR
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub iterator: ::std::option::Option<::std::string::String>,
        ///DTO.ENDPOINT.PAGE.PREV_ITERATOR
        #[serde(
            rename = "prevIterator",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub prev_iterator: ::std::option::Option<::std::string::String>,
    }
    impl ::std::convert::From<&EndpointListResponse> for EndpointListResponse {
        fn from(value: &EndpointListResponse) -> Self {
            value.clone()
        }
    }
    impl ::std::default::Default for EndpointListResponse {
        fn default() -> Self {
            Self {
                data: Default::default(),
                done: Default::default(),
                iterator: Default::default(),
                prev_iterator: Default::default(),
            }
        }
    }
    impl EndpointListResponse {
        pub fn builder() -> builder::EndpointListResponse {
            Default::default()
        }
    }
    ///`EndpointOperationResponse`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "properties": {
    ///    "success": {
    ///      "description": "DTO.ENDPOINT.SUCCESS",
    ///      "examples": [
    ///        true
    ///      ],
    ///      "type": "boolean"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct EndpointOperationResponse {
        ///DTO.ENDPOINT.SUCCESS
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub success: ::std::option::Option<bool>,
    }
    impl ::std::convert::From<&EndpointOperationResponse> for EndpointOperationResponse {
        fn from(value: &EndpointOperationResponse) -> Self {
            value.clone()
        }
    }
    impl ::std::default::Default for EndpointOperationResponse {
        fn default() -> Self {
            Self {
                success: Default::default(),
            }
        }
    }
    impl EndpointOperationResponse {
        pub fn builder() -> builder::EndpointOperationResponse {
            Default::default()
        }
    }
    ///`EndpointResponse`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "properties": {
    ///    "channels": {
    ///      "description": "DTO.ENDPOINT.CHANNELS",
    ///      "examples": [
    ///        [
    ///          "sol.token.migrated",
    ///          "sol.token.created"
    ///        ]
    ///      ],
    ///      "type": "array",
    ///      "items": {
    ///        "type": "string",
    ///        "enum": [
    ///          "sol.token.migrated",
    ///          "sol.token.created"
    ///        ]
    ///      }
    ///    },
    ///    "createdAt": {
    ///      "description": "DTO.ENDPOINT.CREATED_AT",
    ///      "examples": [
    ///        "2021-01-01"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "description": {
    ///      "description": "DTO.ENDPOINT.DESCRIPTION",
    ///      "examples": [
    ///        "Webhook description"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "disabled": {
    ///      "description": "DTO.ENDPOINT.DISABLED",
    ///      "examples": [
    ///        false
    ///      ],
    ///      "type": "boolean"
    ///    },
    ///    "filter": {
    ///      "description": "DTO.ENDPOINT.FILTER",
    ///      "type": "string"
    ///    },
    ///    "filterTypes": {
    ///      "description": "DTO.ENDPOINT.FILTER_TYPES",
    ///      "type": "array",
    ///      "items": {
    ///        "type": "string"
    ///      }
    ///    },
    ///    "id": {
    ///      "description": "DTO.ENDPOINT.ID",
    ///      "examples": [
    ///        "123"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "metadata": {
    ///      "description": "DTO.ENDPOINT.METADATA",
    ///      "examples": [
    ///        {
    ///          "key": "value"
    ///        }
    ///      ],
    ///      "type": "object"
    ///    },
    ///    "rateLimit": {
    ///      "description": "DTO.ENDPOINT.RATE_LIMIT",
    ///      "examples": [
    ///        1000
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "updatedAt": {
    ///      "description": "DTO.ENDPOINT.UPDATED_AT",
    ///      "examples": [
    ///        "2021-01-01"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "url": {
    ///      "description": "DTO.ENDPOINT.URL",
    ///      "examples": [
    ///        "https://example.com"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct EndpointResponse {
        ///DTO.ENDPOINT.CHANNELS
        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
        pub channels: ::std::vec::Vec<EndpointResponseChannelsItem>,
        ///DTO.ENDPOINT.CREATED_AT
        #[serde(
            rename = "createdAt",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub created_at: ::std::option::Option<::std::string::String>,
        ///DTO.ENDPOINT.DESCRIPTION
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub description: ::std::option::Option<::std::string::String>,
        ///DTO.ENDPOINT.DISABLED
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub disabled: ::std::option::Option<bool>,
        ///DTO.ENDPOINT.FILTER
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub filter: ::std::option::Option<::std::string::String>,
        ///DTO.ENDPOINT.FILTER_TYPES
        #[serde(
            rename = "filterTypes",
            default,
            skip_serializing_if = "::std::vec::Vec::is_empty"
        )]
        pub filter_types: ::std::vec::Vec<::std::string::String>,
        ///DTO.ENDPOINT.ID
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub id: ::std::option::Option<::std::string::String>,
        ///DTO.ENDPOINT.METADATA
        #[serde(default, skip_serializing_if = "::serde_json::Map::is_empty")]
        pub metadata: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
        ///DTO.ENDPOINT.RATE_LIMIT
        #[serde(
            rename = "rateLimit",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub rate_limit: ::std::option::Option<i64>,
        ///DTO.ENDPOINT.UPDATED_AT
        #[serde(
            rename = "updatedAt",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub updated_at: ::std::option::Option<::std::string::String>,
        ///DTO.ENDPOINT.URL
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub url: ::std::option::Option<::std::string::String>,
    }
    impl ::std::convert::From<&EndpointResponse> for EndpointResponse {
        fn from(value: &EndpointResponse) -> Self {
            value.clone()
        }
    }
    impl ::std::default::Default for EndpointResponse {
        fn default() -> Self {
            Self {
                channels: Default::default(),
                created_at: Default::default(),
                description: Default::default(),
                disabled: Default::default(),
                filter: Default::default(),
                filter_types: Default::default(),
                id: Default::default(),
                metadata: Default::default(),
                rate_limit: Default::default(),
                updated_at: Default::default(),
                url: Default::default(),
            }
        }
    }
    impl EndpointResponse {
        pub fn builder() -> builder::EndpointResponse {
            Default::default()
        }
    }
    ///`EndpointResponseChannelsItem`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "string",
    ///  "enum": [
    ///    "sol.token.migrated",
    ///    "sol.token.created"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum EndpointResponseChannelsItem {
        #[serde(rename = "sol.token.migrated")]
        SolTokenMigrated,
        #[serde(rename = "sol.token.created")]
        SolTokenCreated,
    }
    impl ::std::convert::From<&Self> for EndpointResponseChannelsItem {
        fn from(value: &EndpointResponseChannelsItem) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for EndpointResponseChannelsItem {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::SolTokenMigrated => f.write_str("sol.token.migrated"),
                Self::SolTokenCreated => f.write_str("sol.token.created"),
            }
        }
    }
    impl ::std::str::FromStr for EndpointResponseChannelsItem {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "sol.token.migrated" => Ok(Self::SolTokenMigrated),
                "sol.token.created" => Ok(Self::SolTokenCreated),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for EndpointResponseChannelsItem {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String>
    for EndpointResponseChannelsItem {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String>
    for EndpointResponseChannelsItem {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    ///`EndpointSecretResponse`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "properties": {
    ///    "secret": {
    ///      "description": "DTO.ENDPOINT.SECRET",
    ///      "examples": [
    ///        "whsec_abcdXXX"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct EndpointSecretResponse {
        ///DTO.ENDPOINT.SECRET
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub secret: ::std::option::Option<::std::string::String>,
    }
    impl ::std::convert::From<&EndpointSecretResponse> for EndpointSecretResponse {
        fn from(value: &EndpointSecretResponse) -> Self {
            value.clone()
        }
    }
    impl ::std::default::Default for EndpointSecretResponse {
        fn default() -> Self {
            Self { secret: Default::default() }
        }
    }
    impl EndpointSecretResponse {
        pub fn builder() -> builder::EndpointSecretResponse {
            Default::default()
        }
    }
    ///`EstimateGasLimitInput`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "data",
    ///    "from",
    ///    "to"
    ///  ],
    ///  "properties": {
    ///    "data": {
    ///      "description": "Transaction data (hex)",
    ///      "examples": [
    ///        "0xa9059cbb000000000000000000000000742d35cc6634c0532925a3b8d8c9c4b8a8d4c8b80000000000000000000000000000000000000000000000000de0b6b3a7640000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "from": {
    ///      "description": "From address",
    ///      "examples": [
    ///        "0x742d35Cc6634C0532925a3b8D8C9C4b8a8d4C8b8"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "to": {
    ///      "description": "To address",
    ///      "examples": [
    ///        "0x742d35Cc6634C0532925a3b8D8C9C4b8a8d4C8b8"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "value": {
    ///      "description": "Value to send (in wei, hex string)",
    ///      "examples": [
    ///        "0x0"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct EstimateGasLimitInput {
        ///Transaction data (hex)
        pub data: ::std::string::String,
        ///From address
        pub from: ::std::string::String,
        ///To address
        pub to: ::std::string::String,
        ///Value to send (in wei, hex string)
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub value: ::std::option::Option<::std::string::String>,
    }
    impl ::std::convert::From<&EstimateGasLimitInput> for EstimateGasLimitInput {
        fn from(value: &EstimateGasLimitInput) -> Self {
            value.clone()
        }
    }
    impl EstimateGasLimitInput {
        pub fn builder() -> builder::EstimateGasLimitInput {
            Default::default()
        }
    }
    ///`EstimateGasLimitResponse`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "chain",
    ///    "gasLimit"
    ///  ],
    ///  "properties": {
    ///    "chain": {
    ///      "description": "Chain symbol",
    ///      "examples": [
    ///        "ethereum"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "gasLimit": {
    ///      "description": "Estimated gas limit (hex string)",
    ///      "examples": [
    ///        "0x5208"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct EstimateGasLimitResponse {
        ///Chain symbol
        pub chain: ::std::string::String,
        ///Estimated gas limit (hex string)
        #[serde(rename = "gasLimit")]
        pub gas_limit: ::std::string::String,
    }
    impl ::std::convert::From<&EstimateGasLimitResponse> for EstimateGasLimitResponse {
        fn from(value: &EstimateGasLimitResponse) -> Self {
            value.clone()
        }
    }
    impl EstimateGasLimitResponse {
        pub fn builder() -> builder::EstimateGasLimitResponse {
            Default::default()
        }
    }
    ///`FilterCondition`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "properties": {
    ///    "field": {
    ///      "description": "DTO.TOKEN.FILTER.FIELD",
    ///      "examples": [
    ///        "marketData.marketCapInUsd"
    ///      ],
    ///      "type": "string",
    ///      "enum": [
    ///        "marketData.priceInUsd",
    ///        "stats.priceChangeRatioInUsd1m",
    ///        "stats.priceChangeRatioInUsd5m",
    ///        "stats.priceChangeRatioInUsd1h",
    ///        "stats.priceChangeRatioInUsd4h",
    ///        "stats.priceChangeRatioInUsd24h",
    ///        "marketData.marketCapInUsd",
    ///        "marketData.maxPoolTvlInUsd",
    ///        "marketData.totalTvlInUsd",
    ///        "marketData.top10TotalHoldings",
    ///        "marketData.top10HoldingsRatio",
    ///        "marketData.top100TotalHoldings",
    ///        "marketData.top100HoldingsRatio",
    ///        "marketData.holders",
    ///        "marketData.creatorHoldings",
    ///        "marketData.creatorHoldingsRatio",
    ///        "stats.buys1m",
    ///        "stats.buys5m",
    ///        "stats.buys15m",
    ///        "stats.buys30m",
    ///        "stats.buys1h",
    ///        "stats.buys4h",
    ///        "stats.buys24h",
    ///        "stats.sells1m",
    ///        "stats.sells5m",
    ///        "stats.sells15m",
    ///        "stats.sells30m",
    ///        "stats.sells1h",
    ///        "stats.sells4h",
    ///        "stats.sells24h",
    ///        "stats.trades1m",
    ///        "stats.trades5m",
    ///        "stats.trades1h",
    ///        "stats.trades4h",
    ///        "stats.trades24h",
    ///        "stats.traders1m",
    ///        "stats.traders5m",
    ///        "stats.traders1h",
    ///        "stats.traders4h",
    ///        "stats.traders24h",
    ///        "stats.volumesInUsd1m",
    ///        "stats.volumesInUsd5m",
    ///        "stats.volumesInUsd1h",
    ///        "stats.volumesInUsd4h",
    ///        "stats.volumesInUsd24h",
    ///        "tokenCreatedAt"
    ///      ]
    ///    },
    ///    "max": {
    ///      "description": "DTO.TOKEN.FILTER.MAX",
    ///      "examples": [
    ///        "10000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "min": {
    ///      "description": "DTO.TOKEN.FILTER.MIN",
    ///      "examples": [
    ///        "1000"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct FilterCondition {
        ///DTO.TOKEN.FILTER.FIELD
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub field: ::std::option::Option<FilterConditionField>,
        ///DTO.TOKEN.FILTER.MAX
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub max: ::std::option::Option<::std::string::String>,
        ///DTO.TOKEN.FILTER.MIN
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub min: ::std::option::Option<::std::string::String>,
    }
    impl ::std::convert::From<&FilterCondition> for FilterCondition {
        fn from(value: &FilterCondition) -> Self {
            value.clone()
        }
    }
    impl ::std::default::Default for FilterCondition {
        fn default() -> Self {
            Self {
                field: Default::default(),
                max: Default::default(),
                min: Default::default(),
            }
        }
    }
    impl FilterCondition {
        pub fn builder() -> builder::FilterCondition {
            Default::default()
        }
    }
    ///DTO.TOKEN.FILTER.FIELD
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "DTO.TOKEN.FILTER.FIELD",
    ///  "examples": [
    ///    "marketData.marketCapInUsd"
    ///  ],
    ///  "type": "string",
    ///  "enum": [
    ///    "marketData.priceInUsd",
    ///    "stats.priceChangeRatioInUsd1m",
    ///    "stats.priceChangeRatioInUsd5m",
    ///    "stats.priceChangeRatioInUsd1h",
    ///    "stats.priceChangeRatioInUsd4h",
    ///    "stats.priceChangeRatioInUsd24h",
    ///    "marketData.marketCapInUsd",
    ///    "marketData.maxPoolTvlInUsd",
    ///    "marketData.totalTvlInUsd",
    ///    "marketData.top10TotalHoldings",
    ///    "marketData.top10HoldingsRatio",
    ///    "marketData.top100TotalHoldings",
    ///    "marketData.top100HoldingsRatio",
    ///    "marketData.holders",
    ///    "marketData.creatorHoldings",
    ///    "marketData.creatorHoldingsRatio",
    ///    "stats.buys1m",
    ///    "stats.buys5m",
    ///    "stats.buys15m",
    ///    "stats.buys30m",
    ///    "stats.buys1h",
    ///    "stats.buys4h",
    ///    "stats.buys24h",
    ///    "stats.sells1m",
    ///    "stats.sells5m",
    ///    "stats.sells15m",
    ///    "stats.sells30m",
    ///    "stats.sells1h",
    ///    "stats.sells4h",
    ///    "stats.sells24h",
    ///    "stats.trades1m",
    ///    "stats.trades5m",
    ///    "stats.trades1h",
    ///    "stats.trades4h",
    ///    "stats.trades24h",
    ///    "stats.traders1m",
    ///    "stats.traders5m",
    ///    "stats.traders1h",
    ///    "stats.traders4h",
    ///    "stats.traders24h",
    ///    "stats.volumesInUsd1m",
    ///    "stats.volumesInUsd5m",
    ///    "stats.volumesInUsd1h",
    ///    "stats.volumesInUsd4h",
    ///    "stats.volumesInUsd24h",
    ///    "tokenCreatedAt"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum FilterConditionField {
        #[serde(rename = "marketData.priceInUsd")]
        MarketDataPriceInUsd,
        #[serde(rename = "stats.priceChangeRatioInUsd1m")]
        StatsPriceChangeRatioInUsd1m,
        #[serde(rename = "stats.priceChangeRatioInUsd5m")]
        StatsPriceChangeRatioInUsd5m,
        #[serde(rename = "stats.priceChangeRatioInUsd1h")]
        StatsPriceChangeRatioInUsd1h,
        #[serde(rename = "stats.priceChangeRatioInUsd4h")]
        StatsPriceChangeRatioInUsd4h,
        #[serde(rename = "stats.priceChangeRatioInUsd24h")]
        StatsPriceChangeRatioInUsd24h,
        #[serde(rename = "marketData.marketCapInUsd")]
        MarketDataMarketCapInUsd,
        #[serde(rename = "marketData.maxPoolTvlInUsd")]
        MarketDataMaxPoolTvlInUsd,
        #[serde(rename = "marketData.totalTvlInUsd")]
        MarketDataTotalTvlInUsd,
        #[serde(rename = "marketData.top10TotalHoldings")]
        MarketDataTop10TotalHoldings,
        #[serde(rename = "marketData.top10HoldingsRatio")]
        MarketDataTop10HoldingsRatio,
        #[serde(rename = "marketData.top100TotalHoldings")]
        MarketDataTop100TotalHoldings,
        #[serde(rename = "marketData.top100HoldingsRatio")]
        MarketDataTop100HoldingsRatio,
        #[serde(rename = "marketData.holders")]
        MarketDataHolders,
        #[serde(rename = "marketData.creatorHoldings")]
        MarketDataCreatorHoldings,
        #[serde(rename = "marketData.creatorHoldingsRatio")]
        MarketDataCreatorHoldingsRatio,
        #[serde(rename = "stats.buys1m")]
        StatsBuys1m,
        #[serde(rename = "stats.buys5m")]
        StatsBuys5m,
        #[serde(rename = "stats.buys15m")]
        StatsBuys15m,
        #[serde(rename = "stats.buys30m")]
        StatsBuys30m,
        #[serde(rename = "stats.buys1h")]
        StatsBuys1h,
        #[serde(rename = "stats.buys4h")]
        StatsBuys4h,
        #[serde(rename = "stats.buys24h")]
        StatsBuys24h,
        #[serde(rename = "stats.sells1m")]
        StatsSells1m,
        #[serde(rename = "stats.sells5m")]
        StatsSells5m,
        #[serde(rename = "stats.sells15m")]
        StatsSells15m,
        #[serde(rename = "stats.sells30m")]
        StatsSells30m,
        #[serde(rename = "stats.sells1h")]
        StatsSells1h,
        #[serde(rename = "stats.sells4h")]
        StatsSells4h,
        #[serde(rename = "stats.sells24h")]
        StatsSells24h,
        #[serde(rename = "stats.trades1m")]
        StatsTrades1m,
        #[serde(rename = "stats.trades5m")]
        StatsTrades5m,
        #[serde(rename = "stats.trades1h")]
        StatsTrades1h,
        #[serde(rename = "stats.trades4h")]
        StatsTrades4h,
        #[serde(rename = "stats.trades24h")]
        StatsTrades24h,
        #[serde(rename = "stats.traders1m")]
        StatsTraders1m,
        #[serde(rename = "stats.traders5m")]
        StatsTraders5m,
        #[serde(rename = "stats.traders1h")]
        StatsTraders1h,
        #[serde(rename = "stats.traders4h")]
        StatsTraders4h,
        #[serde(rename = "stats.traders24h")]
        StatsTraders24h,
        #[serde(rename = "stats.volumesInUsd1m")]
        StatsVolumesInUsd1m,
        #[serde(rename = "stats.volumesInUsd5m")]
        StatsVolumesInUsd5m,
        #[serde(rename = "stats.volumesInUsd1h")]
        StatsVolumesInUsd1h,
        #[serde(rename = "stats.volumesInUsd4h")]
        StatsVolumesInUsd4h,
        #[serde(rename = "stats.volumesInUsd24h")]
        StatsVolumesInUsd24h,
        #[serde(rename = "tokenCreatedAt")]
        TokenCreatedAt,
    }
    impl ::std::convert::From<&Self> for FilterConditionField {
        fn from(value: &FilterConditionField) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for FilterConditionField {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::MarketDataPriceInUsd => f.write_str("marketData.priceInUsd"),
                Self::StatsPriceChangeRatioInUsd1m => {
                    f.write_str("stats.priceChangeRatioInUsd1m")
                }
                Self::StatsPriceChangeRatioInUsd5m => {
                    f.write_str("stats.priceChangeRatioInUsd5m")
                }
                Self::StatsPriceChangeRatioInUsd1h => {
                    f.write_str("stats.priceChangeRatioInUsd1h")
                }
                Self::StatsPriceChangeRatioInUsd4h => {
                    f.write_str("stats.priceChangeRatioInUsd4h")
                }
                Self::StatsPriceChangeRatioInUsd24h => {
                    f.write_str("stats.priceChangeRatioInUsd24h")
                }
                Self::MarketDataMarketCapInUsd => {
                    f.write_str("marketData.marketCapInUsd")
                }
                Self::MarketDataMaxPoolTvlInUsd => {
                    f.write_str("marketData.maxPoolTvlInUsd")
                }
                Self::MarketDataTotalTvlInUsd => f.write_str("marketData.totalTvlInUsd"),
                Self::MarketDataTop10TotalHoldings => {
                    f.write_str("marketData.top10TotalHoldings")
                }
                Self::MarketDataTop10HoldingsRatio => {
                    f.write_str("marketData.top10HoldingsRatio")
                }
                Self::MarketDataTop100TotalHoldings => {
                    f.write_str("marketData.top100TotalHoldings")
                }
                Self::MarketDataTop100HoldingsRatio => {
                    f.write_str("marketData.top100HoldingsRatio")
                }
                Self::MarketDataHolders => f.write_str("marketData.holders"),
                Self::MarketDataCreatorHoldings => {
                    f.write_str("marketData.creatorHoldings")
                }
                Self::MarketDataCreatorHoldingsRatio => {
                    f.write_str("marketData.creatorHoldingsRatio")
                }
                Self::StatsBuys1m => f.write_str("stats.buys1m"),
                Self::StatsBuys5m => f.write_str("stats.buys5m"),
                Self::StatsBuys15m => f.write_str("stats.buys15m"),
                Self::StatsBuys30m => f.write_str("stats.buys30m"),
                Self::StatsBuys1h => f.write_str("stats.buys1h"),
                Self::StatsBuys4h => f.write_str("stats.buys4h"),
                Self::StatsBuys24h => f.write_str("stats.buys24h"),
                Self::StatsSells1m => f.write_str("stats.sells1m"),
                Self::StatsSells5m => f.write_str("stats.sells5m"),
                Self::StatsSells15m => f.write_str("stats.sells15m"),
                Self::StatsSells30m => f.write_str("stats.sells30m"),
                Self::StatsSells1h => f.write_str("stats.sells1h"),
                Self::StatsSells4h => f.write_str("stats.sells4h"),
                Self::StatsSells24h => f.write_str("stats.sells24h"),
                Self::StatsTrades1m => f.write_str("stats.trades1m"),
                Self::StatsTrades5m => f.write_str("stats.trades5m"),
                Self::StatsTrades1h => f.write_str("stats.trades1h"),
                Self::StatsTrades4h => f.write_str("stats.trades4h"),
                Self::StatsTrades24h => f.write_str("stats.trades24h"),
                Self::StatsTraders1m => f.write_str("stats.traders1m"),
                Self::StatsTraders5m => f.write_str("stats.traders5m"),
                Self::StatsTraders1h => f.write_str("stats.traders1h"),
                Self::StatsTraders4h => f.write_str("stats.traders4h"),
                Self::StatsTraders24h => f.write_str("stats.traders24h"),
                Self::StatsVolumesInUsd1m => f.write_str("stats.volumesInUsd1m"),
                Self::StatsVolumesInUsd5m => f.write_str("stats.volumesInUsd5m"),
                Self::StatsVolumesInUsd1h => f.write_str("stats.volumesInUsd1h"),
                Self::StatsVolumesInUsd4h => f.write_str("stats.volumesInUsd4h"),
                Self::StatsVolumesInUsd24h => f.write_str("stats.volumesInUsd24h"),
                Self::TokenCreatedAt => f.write_str("tokenCreatedAt"),
            }
        }
    }
    impl ::std::str::FromStr for FilterConditionField {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "marketData.priceInUsd" => Ok(Self::MarketDataPriceInUsd),
                "stats.priceChangeRatioInUsd1m" => Ok(Self::StatsPriceChangeRatioInUsd1m),
                "stats.priceChangeRatioInUsd5m" => Ok(Self::StatsPriceChangeRatioInUsd5m),
                "stats.priceChangeRatioInUsd1h" => Ok(Self::StatsPriceChangeRatioInUsd1h),
                "stats.priceChangeRatioInUsd4h" => Ok(Self::StatsPriceChangeRatioInUsd4h),
                "stats.priceChangeRatioInUsd24h" => {
                    Ok(Self::StatsPriceChangeRatioInUsd24h)
                }
                "marketData.marketCapInUsd" => Ok(Self::MarketDataMarketCapInUsd),
                "marketData.maxPoolTvlInUsd" => Ok(Self::MarketDataMaxPoolTvlInUsd),
                "marketData.totalTvlInUsd" => Ok(Self::MarketDataTotalTvlInUsd),
                "marketData.top10TotalHoldings" => Ok(Self::MarketDataTop10TotalHoldings),
                "marketData.top10HoldingsRatio" => Ok(Self::MarketDataTop10HoldingsRatio),
                "marketData.top100TotalHoldings" => {
                    Ok(Self::MarketDataTop100TotalHoldings)
                }
                "marketData.top100HoldingsRatio" => {
                    Ok(Self::MarketDataTop100HoldingsRatio)
                }
                "marketData.holders" => Ok(Self::MarketDataHolders),
                "marketData.creatorHoldings" => Ok(Self::MarketDataCreatorHoldings),
                "marketData.creatorHoldingsRatio" => {
                    Ok(Self::MarketDataCreatorHoldingsRatio)
                }
                "stats.buys1m" => Ok(Self::StatsBuys1m),
                "stats.buys5m" => Ok(Self::StatsBuys5m),
                "stats.buys15m" => Ok(Self::StatsBuys15m),
                "stats.buys30m" => Ok(Self::StatsBuys30m),
                "stats.buys1h" => Ok(Self::StatsBuys1h),
                "stats.buys4h" => Ok(Self::StatsBuys4h),
                "stats.buys24h" => Ok(Self::StatsBuys24h),
                "stats.sells1m" => Ok(Self::StatsSells1m),
                "stats.sells5m" => Ok(Self::StatsSells5m),
                "stats.sells15m" => Ok(Self::StatsSells15m),
                "stats.sells30m" => Ok(Self::StatsSells30m),
                "stats.sells1h" => Ok(Self::StatsSells1h),
                "stats.sells4h" => Ok(Self::StatsSells4h),
                "stats.sells24h" => Ok(Self::StatsSells24h),
                "stats.trades1m" => Ok(Self::StatsTrades1m),
                "stats.trades5m" => Ok(Self::StatsTrades5m),
                "stats.trades1h" => Ok(Self::StatsTrades1h),
                "stats.trades4h" => Ok(Self::StatsTrades4h),
                "stats.trades24h" => Ok(Self::StatsTrades24h),
                "stats.traders1m" => Ok(Self::StatsTraders1m),
                "stats.traders5m" => Ok(Self::StatsTraders5m),
                "stats.traders1h" => Ok(Self::StatsTraders1h),
                "stats.traders4h" => Ok(Self::StatsTraders4h),
                "stats.traders24h" => Ok(Self::StatsTraders24h),
                "stats.volumesInUsd1m" => Ok(Self::StatsVolumesInUsd1m),
                "stats.volumesInUsd5m" => Ok(Self::StatsVolumesInUsd5m),
                "stats.volumesInUsd1h" => Ok(Self::StatsVolumesInUsd1h),
                "stats.volumesInUsd4h" => Ok(Self::StatsVolumesInUsd4h),
                "stats.volumesInUsd24h" => Ok(Self::StatsVolumesInUsd24h),
                "tokenCreatedAt" => Ok(Self::TokenCreatedAt),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for FilterConditionField {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String> for FilterConditionField {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for FilterConditionField {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    ///`GasPriceResponse`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "chain",
    ///    "gasPrice"
    ///  ],
    ///  "properties": {
    ///    "chain": {
    ///      "description": "Chain symbol",
    ///      "examples": [
    ///        "ethereum"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "gasPrice": {
    ///      "description": "Current gas price in wei (hex string)",
    ///      "examples": [
    ///        "0x5d21dba00"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct GasPriceResponse {
        ///Chain symbol
        pub chain: ::std::string::String,
        ///Current gas price in wei (hex string)
        #[serde(rename = "gasPrice")]
        pub gas_price: ::std::string::String,
    }
    impl ::std::convert::From<&GasPriceResponse> for GasPriceResponse {
        fn from(value: &GasPriceResponse) -> Self {
            value.clone()
        }
    }
    impl GasPriceResponse {
        pub fn builder() -> builder::GasPriceResponse {
            Default::default()
        }
    }
    ///`GetActivitiesDirection`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "default": "next",
    ///  "type": "string",
    ///  "enum": [
    ///    "next",
    ///    "prev"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum GetActivitiesDirection {
        #[serde(rename = "next")]
        Next,
        #[serde(rename = "prev")]
        Prev,
    }
    impl ::std::convert::From<&Self> for GetActivitiesDirection {
        fn from(value: &GetActivitiesDirection) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for GetActivitiesDirection {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::Next => f.write_str("next"),
                Self::Prev => f.write_str("prev"),
            }
        }
    }
    impl ::std::str::FromStr for GetActivitiesDirection {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "next" => Ok(Self::Next),
                "prev" => Ok(Self::Prev),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for GetActivitiesDirection {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String> for GetActivitiesDirection {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for GetActivitiesDirection {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::default::Default for GetActivitiesDirection {
        fn default() -> Self {
            GetActivitiesDirection::Next
        }
    }
    ///`GetActivitiesType`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "examples": [
    ///    "BUY"
    ///  ],
    ///  "type": "string",
    ///  "enum": [
    ///    "BUY",
    ///    "SELL",
    ///    "LIQUIDITY_INITIALIZE",
    ///    "LIQUIDITY_ADD",
    ///    "LIQUIDITY_REMOVE",
    ///    "RED_PACKET_CREATE",
    ///    "RED_PACKET_CLAIM",
    ///    "RED_PACKET_COMPLETE",
    ///    "RED_PACKET_REFUND"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum GetActivitiesType {
        #[serde(rename = "BUY")]
        Buy,
        #[serde(rename = "SELL")]
        Sell,
        #[serde(rename = "LIQUIDITY_INITIALIZE")]
        LiquidityInitialize,
        #[serde(rename = "LIQUIDITY_ADD")]
        LiquidityAdd,
        #[serde(rename = "LIQUIDITY_REMOVE")]
        LiquidityRemove,
        #[serde(rename = "RED_PACKET_CREATE")]
        RedPacketCreate,
        #[serde(rename = "RED_PACKET_CLAIM")]
        RedPacketClaim,
        #[serde(rename = "RED_PACKET_COMPLETE")]
        RedPacketComplete,
        #[serde(rename = "RED_PACKET_REFUND")]
        RedPacketRefund,
    }
    impl ::std::convert::From<&Self> for GetActivitiesType {
        fn from(value: &GetActivitiesType) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for GetActivitiesType {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::Buy => f.write_str("BUY"),
                Self::Sell => f.write_str("SELL"),
                Self::LiquidityInitialize => f.write_str("LIQUIDITY_INITIALIZE"),
                Self::LiquidityAdd => f.write_str("LIQUIDITY_ADD"),
                Self::LiquidityRemove => f.write_str("LIQUIDITY_REMOVE"),
                Self::RedPacketCreate => f.write_str("RED_PACKET_CREATE"),
                Self::RedPacketClaim => f.write_str("RED_PACKET_CLAIM"),
                Self::RedPacketComplete => f.write_str("RED_PACKET_COMPLETE"),
                Self::RedPacketRefund => f.write_str("RED_PACKET_REFUND"),
            }
        }
    }
    impl ::std::str::FromStr for GetActivitiesType {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "BUY" => Ok(Self::Buy),
                "SELL" => Ok(Self::Sell),
                "LIQUIDITY_INITIALIZE" => Ok(Self::LiquidityInitialize),
                "LIQUIDITY_ADD" => Ok(Self::LiquidityAdd),
                "LIQUIDITY_REMOVE" => Ok(Self::LiquidityRemove),
                "RED_PACKET_CREATE" => Ok(Self::RedPacketCreate),
                "RED_PACKET_CLAIM" => Ok(Self::RedPacketClaim),
                "RED_PACKET_COMPLETE" => Ok(Self::RedPacketComplete),
                "RED_PACKET_REFUND" => Ok(Self::RedPacketRefund),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for GetActivitiesType {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String> for GetActivitiesType {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for GetActivitiesType {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    ///`GetBalanceUpdatesDirection`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "default": "next",
    ///  "type": "string",
    ///  "enum": [
    ///    "next",
    ///    "prev"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum GetBalanceUpdatesDirection {
        #[serde(rename = "next")]
        Next,
        #[serde(rename = "prev")]
        Prev,
    }
    impl ::std::convert::From<&Self> for GetBalanceUpdatesDirection {
        fn from(value: &GetBalanceUpdatesDirection) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for GetBalanceUpdatesDirection {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::Next => f.write_str("next"),
                Self::Prev => f.write_str("prev"),
            }
        }
    }
    impl ::std::str::FromStr for GetBalanceUpdatesDirection {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "next" => Ok(Self::Next),
                "prev" => Ok(Self::Prev),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for GetBalanceUpdatesDirection {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String> for GetBalanceUpdatesDirection {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for GetBalanceUpdatesDirection {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::default::Default for GetBalanceUpdatesDirection {
        fn default() -> Self {
            GetBalanceUpdatesDirection::Next
        }
    }
    ///`GetDexpoolSnapshotsDirection`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "default": "next",
    ///  "type": "string",
    ///  "enum": [
    ///    "next",
    ///    "prev"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum GetDexpoolSnapshotsDirection {
        #[serde(rename = "next")]
        Next,
        #[serde(rename = "prev")]
        Prev,
    }
    impl ::std::convert::From<&Self> for GetDexpoolSnapshotsDirection {
        fn from(value: &GetDexpoolSnapshotsDirection) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for GetDexpoolSnapshotsDirection {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::Next => f.write_str("next"),
                Self::Prev => f.write_str("prev"),
            }
        }
    }
    impl ::std::str::FromStr for GetDexpoolSnapshotsDirection {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "next" => Ok(Self::Next),
                "prev" => Ok(Self::Prev),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for GetDexpoolSnapshotsDirection {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String>
    for GetDexpoolSnapshotsDirection {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String>
    for GetDexpoolSnapshotsDirection {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::default::Default for GetDexpoolSnapshotsDirection {
        fn default() -> Self {
            GetDexpoolSnapshotsDirection::Next
        }
    }
    ///`GetFinalStretchTokensSortBy`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "examples": [
    ///    "marketData.marketCapInUsd"
    ///  ],
    ///  "type": "string",
    ///  "enum": [
    ///    "marketData.priceInUsd",
    ///    "stats.priceChangeRatioInUsd1m",
    ///    "stats.priceChangeRatioInUsd5m",
    ///    "stats.priceChangeRatioInUsd1h",
    ///    "stats.priceChangeRatioInUsd4h",
    ///    "stats.priceChangeRatioInUsd24h",
    ///    "marketData.marketCapInUsd",
    ///    "marketData.maxPoolTvlInUsd",
    ///    "marketData.totalTvlInUsd",
    ///    "marketData.top10TotalHoldings",
    ///    "marketData.top10HoldingsRatio",
    ///    "marketData.top100TotalHoldings",
    ///    "marketData.top100HoldingsRatio",
    ///    "marketData.holders",
    ///    "marketData.creatorHoldings",
    ///    "marketData.creatorHoldingsRatio",
    ///    "stats.buys1m",
    ///    "stats.buys5m",
    ///    "stats.buys15m",
    ///    "stats.buys30m",
    ///    "stats.buys1h",
    ///    "stats.buys4h",
    ///    "stats.buys24h",
    ///    "stats.sells1m",
    ///    "stats.sells5m",
    ///    "stats.sells15m",
    ///    "stats.sells30m",
    ///    "stats.sells1h",
    ///    "stats.sells4h",
    ///    "stats.sells24h",
    ///    "stats.trades1m",
    ///    "stats.trades5m",
    ///    "stats.trades1h",
    ///    "stats.trades4h",
    ///    "stats.trades24h",
    ///    "stats.traders1m",
    ///    "stats.traders5m",
    ///    "stats.traders1h",
    ///    "stats.traders4h",
    ///    "stats.traders24h",
    ///    "stats.volumesInUsd1m",
    ///    "stats.volumesInUsd5m",
    ///    "stats.volumesInUsd1h",
    ///    "stats.volumesInUsd4h",
    ///    "stats.volumesInUsd24h",
    ///    "tokenCreatedAt"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum GetFinalStretchTokensSortBy {
        #[serde(rename = "marketData.priceInUsd")]
        MarketDataPriceInUsd,
        #[serde(rename = "stats.priceChangeRatioInUsd1m")]
        StatsPriceChangeRatioInUsd1m,
        #[serde(rename = "stats.priceChangeRatioInUsd5m")]
        StatsPriceChangeRatioInUsd5m,
        #[serde(rename = "stats.priceChangeRatioInUsd1h")]
        StatsPriceChangeRatioInUsd1h,
        #[serde(rename = "stats.priceChangeRatioInUsd4h")]
        StatsPriceChangeRatioInUsd4h,
        #[serde(rename = "stats.priceChangeRatioInUsd24h")]
        StatsPriceChangeRatioInUsd24h,
        #[serde(rename = "marketData.marketCapInUsd")]
        MarketDataMarketCapInUsd,
        #[serde(rename = "marketData.maxPoolTvlInUsd")]
        MarketDataMaxPoolTvlInUsd,
        #[serde(rename = "marketData.totalTvlInUsd")]
        MarketDataTotalTvlInUsd,
        #[serde(rename = "marketData.top10TotalHoldings")]
        MarketDataTop10TotalHoldings,
        #[serde(rename = "marketData.top10HoldingsRatio")]
        MarketDataTop10HoldingsRatio,
        #[serde(rename = "marketData.top100TotalHoldings")]
        MarketDataTop100TotalHoldings,
        #[serde(rename = "marketData.top100HoldingsRatio")]
        MarketDataTop100HoldingsRatio,
        #[serde(rename = "marketData.holders")]
        MarketDataHolders,
        #[serde(rename = "marketData.creatorHoldings")]
        MarketDataCreatorHoldings,
        #[serde(rename = "marketData.creatorHoldingsRatio")]
        MarketDataCreatorHoldingsRatio,
        #[serde(rename = "stats.buys1m")]
        StatsBuys1m,
        #[serde(rename = "stats.buys5m")]
        StatsBuys5m,
        #[serde(rename = "stats.buys15m")]
        StatsBuys15m,
        #[serde(rename = "stats.buys30m")]
        StatsBuys30m,
        #[serde(rename = "stats.buys1h")]
        StatsBuys1h,
        #[serde(rename = "stats.buys4h")]
        StatsBuys4h,
        #[serde(rename = "stats.buys24h")]
        StatsBuys24h,
        #[serde(rename = "stats.sells1m")]
        StatsSells1m,
        #[serde(rename = "stats.sells5m")]
        StatsSells5m,
        #[serde(rename = "stats.sells15m")]
        StatsSells15m,
        #[serde(rename = "stats.sells30m")]
        StatsSells30m,
        #[serde(rename = "stats.sells1h")]
        StatsSells1h,
        #[serde(rename = "stats.sells4h")]
        StatsSells4h,
        #[serde(rename = "stats.sells24h")]
        StatsSells24h,
        #[serde(rename = "stats.trades1m")]
        StatsTrades1m,
        #[serde(rename = "stats.trades5m")]
        StatsTrades5m,
        #[serde(rename = "stats.trades1h")]
        StatsTrades1h,
        #[serde(rename = "stats.trades4h")]
        StatsTrades4h,
        #[serde(rename = "stats.trades24h")]
        StatsTrades24h,
        #[serde(rename = "stats.traders1m")]
        StatsTraders1m,
        #[serde(rename = "stats.traders5m")]
        StatsTraders5m,
        #[serde(rename = "stats.traders1h")]
        StatsTraders1h,
        #[serde(rename = "stats.traders4h")]
        StatsTraders4h,
        #[serde(rename = "stats.traders24h")]
        StatsTraders24h,
        #[serde(rename = "stats.volumesInUsd1m")]
        StatsVolumesInUsd1m,
        #[serde(rename = "stats.volumesInUsd5m")]
        StatsVolumesInUsd5m,
        #[serde(rename = "stats.volumesInUsd1h")]
        StatsVolumesInUsd1h,
        #[serde(rename = "stats.volumesInUsd4h")]
        StatsVolumesInUsd4h,
        #[serde(rename = "stats.volumesInUsd24h")]
        StatsVolumesInUsd24h,
        #[serde(rename = "tokenCreatedAt")]
        TokenCreatedAt,
    }
    impl ::std::convert::From<&Self> for GetFinalStretchTokensSortBy {
        fn from(value: &GetFinalStretchTokensSortBy) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for GetFinalStretchTokensSortBy {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::MarketDataPriceInUsd => f.write_str("marketData.priceInUsd"),
                Self::StatsPriceChangeRatioInUsd1m => {
                    f.write_str("stats.priceChangeRatioInUsd1m")
                }
                Self::StatsPriceChangeRatioInUsd5m => {
                    f.write_str("stats.priceChangeRatioInUsd5m")
                }
                Self::StatsPriceChangeRatioInUsd1h => {
                    f.write_str("stats.priceChangeRatioInUsd1h")
                }
                Self::StatsPriceChangeRatioInUsd4h => {
                    f.write_str("stats.priceChangeRatioInUsd4h")
                }
                Self::StatsPriceChangeRatioInUsd24h => {
                    f.write_str("stats.priceChangeRatioInUsd24h")
                }
                Self::MarketDataMarketCapInUsd => {
                    f.write_str("marketData.marketCapInUsd")
                }
                Self::MarketDataMaxPoolTvlInUsd => {
                    f.write_str("marketData.maxPoolTvlInUsd")
                }
                Self::MarketDataTotalTvlInUsd => f.write_str("marketData.totalTvlInUsd"),
                Self::MarketDataTop10TotalHoldings => {
                    f.write_str("marketData.top10TotalHoldings")
                }
                Self::MarketDataTop10HoldingsRatio => {
                    f.write_str("marketData.top10HoldingsRatio")
                }
                Self::MarketDataTop100TotalHoldings => {
                    f.write_str("marketData.top100TotalHoldings")
                }
                Self::MarketDataTop100HoldingsRatio => {
                    f.write_str("marketData.top100HoldingsRatio")
                }
                Self::MarketDataHolders => f.write_str("marketData.holders"),
                Self::MarketDataCreatorHoldings => {
                    f.write_str("marketData.creatorHoldings")
                }
                Self::MarketDataCreatorHoldingsRatio => {
                    f.write_str("marketData.creatorHoldingsRatio")
                }
                Self::StatsBuys1m => f.write_str("stats.buys1m"),
                Self::StatsBuys5m => f.write_str("stats.buys5m"),
                Self::StatsBuys15m => f.write_str("stats.buys15m"),
                Self::StatsBuys30m => f.write_str("stats.buys30m"),
                Self::StatsBuys1h => f.write_str("stats.buys1h"),
                Self::StatsBuys4h => f.write_str("stats.buys4h"),
                Self::StatsBuys24h => f.write_str("stats.buys24h"),
                Self::StatsSells1m => f.write_str("stats.sells1m"),
                Self::StatsSells5m => f.write_str("stats.sells5m"),
                Self::StatsSells15m => f.write_str("stats.sells15m"),
                Self::StatsSells30m => f.write_str("stats.sells30m"),
                Self::StatsSells1h => f.write_str("stats.sells1h"),
                Self::StatsSells4h => f.write_str("stats.sells4h"),
                Self::StatsSells24h => f.write_str("stats.sells24h"),
                Self::StatsTrades1m => f.write_str("stats.trades1m"),
                Self::StatsTrades5m => f.write_str("stats.trades5m"),
                Self::StatsTrades1h => f.write_str("stats.trades1h"),
                Self::StatsTrades4h => f.write_str("stats.trades4h"),
                Self::StatsTrades24h => f.write_str("stats.trades24h"),
                Self::StatsTraders1m => f.write_str("stats.traders1m"),
                Self::StatsTraders5m => f.write_str("stats.traders5m"),
                Self::StatsTraders1h => f.write_str("stats.traders1h"),
                Self::StatsTraders4h => f.write_str("stats.traders4h"),
                Self::StatsTraders24h => f.write_str("stats.traders24h"),
                Self::StatsVolumesInUsd1m => f.write_str("stats.volumesInUsd1m"),
                Self::StatsVolumesInUsd5m => f.write_str("stats.volumesInUsd5m"),
                Self::StatsVolumesInUsd1h => f.write_str("stats.volumesInUsd1h"),
                Self::StatsVolumesInUsd4h => f.write_str("stats.volumesInUsd4h"),
                Self::StatsVolumesInUsd24h => f.write_str("stats.volumesInUsd24h"),
                Self::TokenCreatedAt => f.write_str("tokenCreatedAt"),
            }
        }
    }
    impl ::std::str::FromStr for GetFinalStretchTokensSortBy {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "marketData.priceInUsd" => Ok(Self::MarketDataPriceInUsd),
                "stats.priceChangeRatioInUsd1m" => Ok(Self::StatsPriceChangeRatioInUsd1m),
                "stats.priceChangeRatioInUsd5m" => Ok(Self::StatsPriceChangeRatioInUsd5m),
                "stats.priceChangeRatioInUsd1h" => Ok(Self::StatsPriceChangeRatioInUsd1h),
                "stats.priceChangeRatioInUsd4h" => Ok(Self::StatsPriceChangeRatioInUsd4h),
                "stats.priceChangeRatioInUsd24h" => {
                    Ok(Self::StatsPriceChangeRatioInUsd24h)
                }
                "marketData.marketCapInUsd" => Ok(Self::MarketDataMarketCapInUsd),
                "marketData.maxPoolTvlInUsd" => Ok(Self::MarketDataMaxPoolTvlInUsd),
                "marketData.totalTvlInUsd" => Ok(Self::MarketDataTotalTvlInUsd),
                "marketData.top10TotalHoldings" => Ok(Self::MarketDataTop10TotalHoldings),
                "marketData.top10HoldingsRatio" => Ok(Self::MarketDataTop10HoldingsRatio),
                "marketData.top100TotalHoldings" => {
                    Ok(Self::MarketDataTop100TotalHoldings)
                }
                "marketData.top100HoldingsRatio" => {
                    Ok(Self::MarketDataTop100HoldingsRatio)
                }
                "marketData.holders" => Ok(Self::MarketDataHolders),
                "marketData.creatorHoldings" => Ok(Self::MarketDataCreatorHoldings),
                "marketData.creatorHoldingsRatio" => {
                    Ok(Self::MarketDataCreatorHoldingsRatio)
                }
                "stats.buys1m" => Ok(Self::StatsBuys1m),
                "stats.buys5m" => Ok(Self::StatsBuys5m),
                "stats.buys15m" => Ok(Self::StatsBuys15m),
                "stats.buys30m" => Ok(Self::StatsBuys30m),
                "stats.buys1h" => Ok(Self::StatsBuys1h),
                "stats.buys4h" => Ok(Self::StatsBuys4h),
                "stats.buys24h" => Ok(Self::StatsBuys24h),
                "stats.sells1m" => Ok(Self::StatsSells1m),
                "stats.sells5m" => Ok(Self::StatsSells5m),
                "stats.sells15m" => Ok(Self::StatsSells15m),
                "stats.sells30m" => Ok(Self::StatsSells30m),
                "stats.sells1h" => Ok(Self::StatsSells1h),
                "stats.sells4h" => Ok(Self::StatsSells4h),
                "stats.sells24h" => Ok(Self::StatsSells24h),
                "stats.trades1m" => Ok(Self::StatsTrades1m),
                "stats.trades5m" => Ok(Self::StatsTrades5m),
                "stats.trades1h" => Ok(Self::StatsTrades1h),
                "stats.trades4h" => Ok(Self::StatsTrades4h),
                "stats.trades24h" => Ok(Self::StatsTrades24h),
                "stats.traders1m" => Ok(Self::StatsTraders1m),
                "stats.traders5m" => Ok(Self::StatsTraders5m),
                "stats.traders1h" => Ok(Self::StatsTraders1h),
                "stats.traders4h" => Ok(Self::StatsTraders4h),
                "stats.traders24h" => Ok(Self::StatsTraders24h),
                "stats.volumesInUsd1m" => Ok(Self::StatsVolumesInUsd1m),
                "stats.volumesInUsd5m" => Ok(Self::StatsVolumesInUsd5m),
                "stats.volumesInUsd1h" => Ok(Self::StatsVolumesInUsd1h),
                "stats.volumesInUsd4h" => Ok(Self::StatsVolumesInUsd4h),
                "stats.volumesInUsd24h" => Ok(Self::StatsVolumesInUsd24h),
                "tokenCreatedAt" => Ok(Self::TokenCreatedAt),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for GetFinalStretchTokensSortBy {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String>
    for GetFinalStretchTokensSortBy {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for GetFinalStretchTokensSortBy {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    ///`GetFinalStretchTokensSortDirection`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "default": "DESC",
    ///  "type": "string",
    ///  "enum": [
    ///    "ASC",
    ///    "DESC"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum GetFinalStretchTokensSortDirection {
        #[serde(rename = "ASC")]
        Asc,
        #[serde(rename = "DESC")]
        Desc,
    }
    impl ::std::convert::From<&Self> for GetFinalStretchTokensSortDirection {
        fn from(value: &GetFinalStretchTokensSortDirection) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for GetFinalStretchTokensSortDirection {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::Asc => f.write_str("ASC"),
                Self::Desc => f.write_str("DESC"),
            }
        }
    }
    impl ::std::str::FromStr for GetFinalStretchTokensSortDirection {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "ASC" => Ok(Self::Asc),
                "DESC" => Ok(Self::Desc),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for GetFinalStretchTokensSortDirection {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String>
    for GetFinalStretchTokensSortDirection {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String>
    for GetFinalStretchTokensSortDirection {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::default::Default for GetFinalStretchTokensSortDirection {
        fn default() -> Self {
            GetFinalStretchTokensSortDirection::Desc
        }
    }
    ///`GetFinalStretchTokensTag`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "string",
    ///  "enum": [
    ///    "pump_fun",
    ///    "raydium_launchpad",
    ///    "meteora_dynamic_bounding_curve",
    ///    "bonk_fun",
    ///    "moonit_fun"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum GetFinalStretchTokensTag {
        #[serde(rename = "pump_fun")]
        PumpFun,
        #[serde(rename = "raydium_launchpad")]
        RaydiumLaunchpad,
        #[serde(rename = "meteora_dynamic_bounding_curve")]
        MeteoraDynamicBoundingCurve,
        #[serde(rename = "bonk_fun")]
        BonkFun,
        #[serde(rename = "moonit_fun")]
        MoonitFun,
    }
    impl ::std::convert::From<&Self> for GetFinalStretchTokensTag {
        fn from(value: &GetFinalStretchTokensTag) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for GetFinalStretchTokensTag {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::PumpFun => f.write_str("pump_fun"),
                Self::RaydiumLaunchpad => f.write_str("raydium_launchpad"),
                Self::MeteoraDynamicBoundingCurve => {
                    f.write_str("meteora_dynamic_bounding_curve")
                }
                Self::BonkFun => f.write_str("bonk_fun"),
                Self::MoonitFun => f.write_str("moonit_fun"),
            }
        }
    }
    impl ::std::str::FromStr for GetFinalStretchTokensTag {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "pump_fun" => Ok(Self::PumpFun),
                "raydium_launchpad" => Ok(Self::RaydiumLaunchpad),
                "meteora_dynamic_bounding_curve" => Ok(Self::MeteoraDynamicBoundingCurve),
                "bonk_fun" => Ok(Self::BonkFun),
                "moonit_fun" => Ok(Self::MoonitFun),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for GetFinalStretchTokensTag {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String> for GetFinalStretchTokensTag {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for GetFinalStretchTokensTag {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    ///`GetGasLimitChain`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "string",
    ///  "enum": [
    ///    "bsc",
    ///    "eth"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum GetGasLimitChain {
        #[serde(rename = "bsc")]
        Bsc,
        #[serde(rename = "eth")]
        Eth,
    }
    impl ::std::convert::From<&Self> for GetGasLimitChain {
        fn from(value: &GetGasLimitChain) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for GetGasLimitChain {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::Bsc => f.write_str("bsc"),
                Self::Eth => f.write_str("eth"),
            }
        }
    }
    impl ::std::str::FromStr for GetGasLimitChain {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "bsc" => Ok(Self::Bsc),
                "eth" => Ok(Self::Eth),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for GetGasLimitChain {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String> for GetGasLimitChain {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for GetGasLimitChain {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    ///`GetGasPriceChain`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "string",
    ///  "enum": [
    ///    "bsc",
    ///    "eth"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum GetGasPriceChain {
        #[serde(rename = "bsc")]
        Bsc,
        #[serde(rename = "eth")]
        Eth,
    }
    impl ::std::convert::From<&Self> for GetGasPriceChain {
        fn from(value: &GetGasPriceChain) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for GetGasPriceChain {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::Bsc => f.write_str("bsc"),
                Self::Eth => f.write_str("eth"),
            }
        }
    }
    impl ::std::str::FromStr for GetGasPriceChain {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "bsc" => Ok(Self::Bsc),
                "eth" => Ok(Self::Eth),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for GetGasPriceChain {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String> for GetGasPriceChain {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for GetGasPriceChain {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    ///`GetHoldersDirection`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "default": "next",
    ///  "type": "string",
    ///  "enum": [
    ///    "next",
    ///    "prev"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum GetHoldersDirection {
        #[serde(rename = "next")]
        Next,
        #[serde(rename = "prev")]
        Prev,
    }
    impl ::std::convert::From<&Self> for GetHoldersDirection {
        fn from(value: &GetHoldersDirection) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for GetHoldersDirection {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::Next => f.write_str("next"),
                Self::Prev => f.write_str("prev"),
            }
        }
    }
    impl ::std::str::FromStr for GetHoldersDirection {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "next" => Ok(Self::Next),
                "prev" => Ok(Self::Prev),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for GetHoldersDirection {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String> for GetHoldersDirection {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for GetHoldersDirection {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::default::Default for GetHoldersDirection {
        fn default() -> Self {
            GetHoldersDirection::Next
        }
    }
    ///`GetHotTokensDuration`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "string",
    ///  "enum": [
    ///    "1m",
    ///    "5m",
    ///    "1h",
    ///    "4h",
    ///    "24h"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum GetHotTokensDuration {
        #[serde(rename = "1m")]
        X1m,
        #[serde(rename = "5m")]
        X5m,
        #[serde(rename = "1h")]
        X1h,
        #[serde(rename = "4h")]
        X4h,
        #[serde(rename = "24h")]
        X24h,
    }
    impl ::std::convert::From<&Self> for GetHotTokensDuration {
        fn from(value: &GetHotTokensDuration) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for GetHotTokensDuration {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::X1m => f.write_str("1m"),
                Self::X5m => f.write_str("5m"),
                Self::X1h => f.write_str("1h"),
                Self::X4h => f.write_str("4h"),
                Self::X24h => f.write_str("24h"),
            }
        }
    }
    impl ::std::str::FromStr for GetHotTokensDuration {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "1m" => Ok(Self::X1m),
                "5m" => Ok(Self::X5m),
                "1h" => Ok(Self::X1h),
                "4h" => Ok(Self::X4h),
                "24h" => Ok(Self::X24h),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for GetHotTokensDuration {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String> for GetHotTokensDuration {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for GetHotTokensDuration {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    ///`GetHotTokensSortBy`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "examples": [
    ///    "marketData.marketCapInUsd"
    ///  ],
    ///  "type": "string",
    ///  "enum": [
    ///    "marketData.priceInUsd",
    ///    "stats.priceChangeRatioInUsd1m",
    ///    "stats.priceChangeRatioInUsd5m",
    ///    "stats.priceChangeRatioInUsd1h",
    ///    "stats.priceChangeRatioInUsd4h",
    ///    "stats.priceChangeRatioInUsd24h",
    ///    "marketData.marketCapInUsd",
    ///    "marketData.maxPoolTvlInUsd",
    ///    "marketData.totalTvlInUsd",
    ///    "marketData.top10TotalHoldings",
    ///    "marketData.top10HoldingsRatio",
    ///    "marketData.top100TotalHoldings",
    ///    "marketData.top100HoldingsRatio",
    ///    "marketData.holders",
    ///    "marketData.creatorHoldings",
    ///    "marketData.creatorHoldingsRatio",
    ///    "stats.buys1m",
    ///    "stats.buys5m",
    ///    "stats.buys15m",
    ///    "stats.buys30m",
    ///    "stats.buys1h",
    ///    "stats.buys4h",
    ///    "stats.buys24h",
    ///    "stats.sells1m",
    ///    "stats.sells5m",
    ///    "stats.sells15m",
    ///    "stats.sells30m",
    ///    "stats.sells1h",
    ///    "stats.sells4h",
    ///    "stats.sells24h",
    ///    "stats.trades1m",
    ///    "stats.trades5m",
    ///    "stats.trades1h",
    ///    "stats.trades4h",
    ///    "stats.trades24h",
    ///    "stats.traders1m",
    ///    "stats.traders5m",
    ///    "stats.traders1h",
    ///    "stats.traders4h",
    ///    "stats.traders24h",
    ///    "stats.volumesInUsd1m",
    ///    "stats.volumesInUsd5m",
    ///    "stats.volumesInUsd1h",
    ///    "stats.volumesInUsd4h",
    ///    "stats.volumesInUsd24h",
    ///    "tokenCreatedAt"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum GetHotTokensSortBy {
        #[serde(rename = "marketData.priceInUsd")]
        MarketDataPriceInUsd,
        #[serde(rename = "stats.priceChangeRatioInUsd1m")]
        StatsPriceChangeRatioInUsd1m,
        #[serde(rename = "stats.priceChangeRatioInUsd5m")]
        StatsPriceChangeRatioInUsd5m,
        #[serde(rename = "stats.priceChangeRatioInUsd1h")]
        StatsPriceChangeRatioInUsd1h,
        #[serde(rename = "stats.priceChangeRatioInUsd4h")]
        StatsPriceChangeRatioInUsd4h,
        #[serde(rename = "stats.priceChangeRatioInUsd24h")]
        StatsPriceChangeRatioInUsd24h,
        #[serde(rename = "marketData.marketCapInUsd")]
        MarketDataMarketCapInUsd,
        #[serde(rename = "marketData.maxPoolTvlInUsd")]
        MarketDataMaxPoolTvlInUsd,
        #[serde(rename = "marketData.totalTvlInUsd")]
        MarketDataTotalTvlInUsd,
        #[serde(rename = "marketData.top10TotalHoldings")]
        MarketDataTop10TotalHoldings,
        #[serde(rename = "marketData.top10HoldingsRatio")]
        MarketDataTop10HoldingsRatio,
        #[serde(rename = "marketData.top100TotalHoldings")]
        MarketDataTop100TotalHoldings,
        #[serde(rename = "marketData.top100HoldingsRatio")]
        MarketDataTop100HoldingsRatio,
        #[serde(rename = "marketData.holders")]
        MarketDataHolders,
        #[serde(rename = "marketData.creatorHoldings")]
        MarketDataCreatorHoldings,
        #[serde(rename = "marketData.creatorHoldingsRatio")]
        MarketDataCreatorHoldingsRatio,
        #[serde(rename = "stats.buys1m")]
        StatsBuys1m,
        #[serde(rename = "stats.buys5m")]
        StatsBuys5m,
        #[serde(rename = "stats.buys15m")]
        StatsBuys15m,
        #[serde(rename = "stats.buys30m")]
        StatsBuys30m,
        #[serde(rename = "stats.buys1h")]
        StatsBuys1h,
        #[serde(rename = "stats.buys4h")]
        StatsBuys4h,
        #[serde(rename = "stats.buys24h")]
        StatsBuys24h,
        #[serde(rename = "stats.sells1m")]
        StatsSells1m,
        #[serde(rename = "stats.sells5m")]
        StatsSells5m,
        #[serde(rename = "stats.sells15m")]
        StatsSells15m,
        #[serde(rename = "stats.sells30m")]
        StatsSells30m,
        #[serde(rename = "stats.sells1h")]
        StatsSells1h,
        #[serde(rename = "stats.sells4h")]
        StatsSells4h,
        #[serde(rename = "stats.sells24h")]
        StatsSells24h,
        #[serde(rename = "stats.trades1m")]
        StatsTrades1m,
        #[serde(rename = "stats.trades5m")]
        StatsTrades5m,
        #[serde(rename = "stats.trades1h")]
        StatsTrades1h,
        #[serde(rename = "stats.trades4h")]
        StatsTrades4h,
        #[serde(rename = "stats.trades24h")]
        StatsTrades24h,
        #[serde(rename = "stats.traders1m")]
        StatsTraders1m,
        #[serde(rename = "stats.traders5m")]
        StatsTraders5m,
        #[serde(rename = "stats.traders1h")]
        StatsTraders1h,
        #[serde(rename = "stats.traders4h")]
        StatsTraders4h,
        #[serde(rename = "stats.traders24h")]
        StatsTraders24h,
        #[serde(rename = "stats.volumesInUsd1m")]
        StatsVolumesInUsd1m,
        #[serde(rename = "stats.volumesInUsd5m")]
        StatsVolumesInUsd5m,
        #[serde(rename = "stats.volumesInUsd1h")]
        StatsVolumesInUsd1h,
        #[serde(rename = "stats.volumesInUsd4h")]
        StatsVolumesInUsd4h,
        #[serde(rename = "stats.volumesInUsd24h")]
        StatsVolumesInUsd24h,
        #[serde(rename = "tokenCreatedAt")]
        TokenCreatedAt,
    }
    impl ::std::convert::From<&Self> for GetHotTokensSortBy {
        fn from(value: &GetHotTokensSortBy) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for GetHotTokensSortBy {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::MarketDataPriceInUsd => f.write_str("marketData.priceInUsd"),
                Self::StatsPriceChangeRatioInUsd1m => {
                    f.write_str("stats.priceChangeRatioInUsd1m")
                }
                Self::StatsPriceChangeRatioInUsd5m => {
                    f.write_str("stats.priceChangeRatioInUsd5m")
                }
                Self::StatsPriceChangeRatioInUsd1h => {
                    f.write_str("stats.priceChangeRatioInUsd1h")
                }
                Self::StatsPriceChangeRatioInUsd4h => {
                    f.write_str("stats.priceChangeRatioInUsd4h")
                }
                Self::StatsPriceChangeRatioInUsd24h => {
                    f.write_str("stats.priceChangeRatioInUsd24h")
                }
                Self::MarketDataMarketCapInUsd => {
                    f.write_str("marketData.marketCapInUsd")
                }
                Self::MarketDataMaxPoolTvlInUsd => {
                    f.write_str("marketData.maxPoolTvlInUsd")
                }
                Self::MarketDataTotalTvlInUsd => f.write_str("marketData.totalTvlInUsd"),
                Self::MarketDataTop10TotalHoldings => {
                    f.write_str("marketData.top10TotalHoldings")
                }
                Self::MarketDataTop10HoldingsRatio => {
                    f.write_str("marketData.top10HoldingsRatio")
                }
                Self::MarketDataTop100TotalHoldings => {
                    f.write_str("marketData.top100TotalHoldings")
                }
                Self::MarketDataTop100HoldingsRatio => {
                    f.write_str("marketData.top100HoldingsRatio")
                }
                Self::MarketDataHolders => f.write_str("marketData.holders"),
                Self::MarketDataCreatorHoldings => {
                    f.write_str("marketData.creatorHoldings")
                }
                Self::MarketDataCreatorHoldingsRatio => {
                    f.write_str("marketData.creatorHoldingsRatio")
                }
                Self::StatsBuys1m => f.write_str("stats.buys1m"),
                Self::StatsBuys5m => f.write_str("stats.buys5m"),
                Self::StatsBuys15m => f.write_str("stats.buys15m"),
                Self::StatsBuys30m => f.write_str("stats.buys30m"),
                Self::StatsBuys1h => f.write_str("stats.buys1h"),
                Self::StatsBuys4h => f.write_str("stats.buys4h"),
                Self::StatsBuys24h => f.write_str("stats.buys24h"),
                Self::StatsSells1m => f.write_str("stats.sells1m"),
                Self::StatsSells5m => f.write_str("stats.sells5m"),
                Self::StatsSells15m => f.write_str("stats.sells15m"),
                Self::StatsSells30m => f.write_str("stats.sells30m"),
                Self::StatsSells1h => f.write_str("stats.sells1h"),
                Self::StatsSells4h => f.write_str("stats.sells4h"),
                Self::StatsSells24h => f.write_str("stats.sells24h"),
                Self::StatsTrades1m => f.write_str("stats.trades1m"),
                Self::StatsTrades5m => f.write_str("stats.trades5m"),
                Self::StatsTrades1h => f.write_str("stats.trades1h"),
                Self::StatsTrades4h => f.write_str("stats.trades4h"),
                Self::StatsTrades24h => f.write_str("stats.trades24h"),
                Self::StatsTraders1m => f.write_str("stats.traders1m"),
                Self::StatsTraders5m => f.write_str("stats.traders5m"),
                Self::StatsTraders1h => f.write_str("stats.traders1h"),
                Self::StatsTraders4h => f.write_str("stats.traders4h"),
                Self::StatsTraders24h => f.write_str("stats.traders24h"),
                Self::StatsVolumesInUsd1m => f.write_str("stats.volumesInUsd1m"),
                Self::StatsVolumesInUsd5m => f.write_str("stats.volumesInUsd5m"),
                Self::StatsVolumesInUsd1h => f.write_str("stats.volumesInUsd1h"),
                Self::StatsVolumesInUsd4h => f.write_str("stats.volumesInUsd4h"),
                Self::StatsVolumesInUsd24h => f.write_str("stats.volumesInUsd24h"),
                Self::TokenCreatedAt => f.write_str("tokenCreatedAt"),
            }
        }
    }
    impl ::std::str::FromStr for GetHotTokensSortBy {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "marketData.priceInUsd" => Ok(Self::MarketDataPriceInUsd),
                "stats.priceChangeRatioInUsd1m" => Ok(Self::StatsPriceChangeRatioInUsd1m),
                "stats.priceChangeRatioInUsd5m" => Ok(Self::StatsPriceChangeRatioInUsd5m),
                "stats.priceChangeRatioInUsd1h" => Ok(Self::StatsPriceChangeRatioInUsd1h),
                "stats.priceChangeRatioInUsd4h" => Ok(Self::StatsPriceChangeRatioInUsd4h),
                "stats.priceChangeRatioInUsd24h" => {
                    Ok(Self::StatsPriceChangeRatioInUsd24h)
                }
                "marketData.marketCapInUsd" => Ok(Self::MarketDataMarketCapInUsd),
                "marketData.maxPoolTvlInUsd" => Ok(Self::MarketDataMaxPoolTvlInUsd),
                "marketData.totalTvlInUsd" => Ok(Self::MarketDataTotalTvlInUsd),
                "marketData.top10TotalHoldings" => Ok(Self::MarketDataTop10TotalHoldings),
                "marketData.top10HoldingsRatio" => Ok(Self::MarketDataTop10HoldingsRatio),
                "marketData.top100TotalHoldings" => {
                    Ok(Self::MarketDataTop100TotalHoldings)
                }
                "marketData.top100HoldingsRatio" => {
                    Ok(Self::MarketDataTop100HoldingsRatio)
                }
                "marketData.holders" => Ok(Self::MarketDataHolders),
                "marketData.creatorHoldings" => Ok(Self::MarketDataCreatorHoldings),
                "marketData.creatorHoldingsRatio" => {
                    Ok(Self::MarketDataCreatorHoldingsRatio)
                }
                "stats.buys1m" => Ok(Self::StatsBuys1m),
                "stats.buys5m" => Ok(Self::StatsBuys5m),
                "stats.buys15m" => Ok(Self::StatsBuys15m),
                "stats.buys30m" => Ok(Self::StatsBuys30m),
                "stats.buys1h" => Ok(Self::StatsBuys1h),
                "stats.buys4h" => Ok(Self::StatsBuys4h),
                "stats.buys24h" => Ok(Self::StatsBuys24h),
                "stats.sells1m" => Ok(Self::StatsSells1m),
                "stats.sells5m" => Ok(Self::StatsSells5m),
                "stats.sells15m" => Ok(Self::StatsSells15m),
                "stats.sells30m" => Ok(Self::StatsSells30m),
                "stats.sells1h" => Ok(Self::StatsSells1h),
                "stats.sells4h" => Ok(Self::StatsSells4h),
                "stats.sells24h" => Ok(Self::StatsSells24h),
                "stats.trades1m" => Ok(Self::StatsTrades1m),
                "stats.trades5m" => Ok(Self::StatsTrades5m),
                "stats.trades1h" => Ok(Self::StatsTrades1h),
                "stats.trades4h" => Ok(Self::StatsTrades4h),
                "stats.trades24h" => Ok(Self::StatsTrades24h),
                "stats.traders1m" => Ok(Self::StatsTraders1m),
                "stats.traders5m" => Ok(Self::StatsTraders5m),
                "stats.traders1h" => Ok(Self::StatsTraders1h),
                "stats.traders4h" => Ok(Self::StatsTraders4h),
                "stats.traders24h" => Ok(Self::StatsTraders24h),
                "stats.volumesInUsd1m" => Ok(Self::StatsVolumesInUsd1m),
                "stats.volumesInUsd5m" => Ok(Self::StatsVolumesInUsd5m),
                "stats.volumesInUsd1h" => Ok(Self::StatsVolumesInUsd1h),
                "stats.volumesInUsd4h" => Ok(Self::StatsVolumesInUsd4h),
                "stats.volumesInUsd24h" => Ok(Self::StatsVolumesInUsd24h),
                "tokenCreatedAt" => Ok(Self::TokenCreatedAt),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for GetHotTokensSortBy {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String> for GetHotTokensSortBy {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for GetHotTokensSortBy {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    ///`GetHotTokensSortDirection`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "default": "DESC",
    ///  "type": "string",
    ///  "enum": [
    ///    "ASC",
    ///    "DESC"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum GetHotTokensSortDirection {
        #[serde(rename = "ASC")]
        Asc,
        #[serde(rename = "DESC")]
        Desc,
    }
    impl ::std::convert::From<&Self> for GetHotTokensSortDirection {
        fn from(value: &GetHotTokensSortDirection) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for GetHotTokensSortDirection {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::Asc => f.write_str("ASC"),
                Self::Desc => f.write_str("DESC"),
            }
        }
    }
    impl ::std::str::FromStr for GetHotTokensSortDirection {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "ASC" => Ok(Self::Asc),
                "DESC" => Ok(Self::Desc),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for GetHotTokensSortDirection {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String> for GetHotTokensSortDirection {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for GetHotTokensSortDirection {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::default::Default for GetHotTokensSortDirection {
        fn default() -> Self {
            GetHotTokensSortDirection::Desc
        }
    }
    ///`GetHotTokensTag`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "string",
    ///  "enum": [
    ///    "pump_fun",
    ///    "raydium_launchpad",
    ///    "meteora_dynamic_bounding_curve",
    ///    "bonk_fun",
    ///    "moonit_fun"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum GetHotTokensTag {
        #[serde(rename = "pump_fun")]
        PumpFun,
        #[serde(rename = "raydium_launchpad")]
        RaydiumLaunchpad,
        #[serde(rename = "meteora_dynamic_bounding_curve")]
        MeteoraDynamicBoundingCurve,
        #[serde(rename = "bonk_fun")]
        BonkFun,
        #[serde(rename = "moonit_fun")]
        MoonitFun,
    }
    impl ::std::convert::From<&Self> for GetHotTokensTag {
        fn from(value: &GetHotTokensTag) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for GetHotTokensTag {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::PumpFun => f.write_str("pump_fun"),
                Self::RaydiumLaunchpad => f.write_str("raydium_launchpad"),
                Self::MeteoraDynamicBoundingCurve => {
                    f.write_str("meteora_dynamic_bounding_curve")
                }
                Self::BonkFun => f.write_str("bonk_fun"),
                Self::MoonitFun => f.write_str("moonit_fun"),
            }
        }
    }
    impl ::std::str::FromStr for GetHotTokensTag {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "pump_fun" => Ok(Self::PumpFun),
                "raydium_launchpad" => Ok(Self::RaydiumLaunchpad),
                "meteora_dynamic_bounding_curve" => Ok(Self::MeteoraDynamicBoundingCurve),
                "bonk_fun" => Ok(Self::BonkFun),
                "moonit_fun" => Ok(Self::MoonitFun),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for GetHotTokensTag {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String> for GetHotTokensTag {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for GetHotTokensTag {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    ///`GetMigratedTokensSortBy`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "examples": [
    ///    "marketData.marketCapInUsd"
    ///  ],
    ///  "type": "string",
    ///  "enum": [
    ///    "marketData.priceInUsd",
    ///    "stats.priceChangeRatioInUsd1m",
    ///    "stats.priceChangeRatioInUsd5m",
    ///    "stats.priceChangeRatioInUsd1h",
    ///    "stats.priceChangeRatioInUsd4h",
    ///    "stats.priceChangeRatioInUsd24h",
    ///    "marketData.marketCapInUsd",
    ///    "marketData.maxPoolTvlInUsd",
    ///    "marketData.totalTvlInUsd",
    ///    "marketData.top10TotalHoldings",
    ///    "marketData.top10HoldingsRatio",
    ///    "marketData.top100TotalHoldings",
    ///    "marketData.top100HoldingsRatio",
    ///    "marketData.holders",
    ///    "marketData.creatorHoldings",
    ///    "marketData.creatorHoldingsRatio",
    ///    "stats.buys1m",
    ///    "stats.buys5m",
    ///    "stats.buys15m",
    ///    "stats.buys30m",
    ///    "stats.buys1h",
    ///    "stats.buys4h",
    ///    "stats.buys24h",
    ///    "stats.sells1m",
    ///    "stats.sells5m",
    ///    "stats.sells15m",
    ///    "stats.sells30m",
    ///    "stats.sells1h",
    ///    "stats.sells4h",
    ///    "stats.sells24h",
    ///    "stats.trades1m",
    ///    "stats.trades5m",
    ///    "stats.trades1h",
    ///    "stats.trades4h",
    ///    "stats.trades24h",
    ///    "stats.traders1m",
    ///    "stats.traders5m",
    ///    "stats.traders1h",
    ///    "stats.traders4h",
    ///    "stats.traders24h",
    ///    "stats.volumesInUsd1m",
    ///    "stats.volumesInUsd5m",
    ///    "stats.volumesInUsd1h",
    ///    "stats.volumesInUsd4h",
    ///    "stats.volumesInUsd24h",
    ///    "tokenCreatedAt"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum GetMigratedTokensSortBy {
        #[serde(rename = "marketData.priceInUsd")]
        MarketDataPriceInUsd,
        #[serde(rename = "stats.priceChangeRatioInUsd1m")]
        StatsPriceChangeRatioInUsd1m,
        #[serde(rename = "stats.priceChangeRatioInUsd5m")]
        StatsPriceChangeRatioInUsd5m,
        #[serde(rename = "stats.priceChangeRatioInUsd1h")]
        StatsPriceChangeRatioInUsd1h,
        #[serde(rename = "stats.priceChangeRatioInUsd4h")]
        StatsPriceChangeRatioInUsd4h,
        #[serde(rename = "stats.priceChangeRatioInUsd24h")]
        StatsPriceChangeRatioInUsd24h,
        #[serde(rename = "marketData.marketCapInUsd")]
        MarketDataMarketCapInUsd,
        #[serde(rename = "marketData.maxPoolTvlInUsd")]
        MarketDataMaxPoolTvlInUsd,
        #[serde(rename = "marketData.totalTvlInUsd")]
        MarketDataTotalTvlInUsd,
        #[serde(rename = "marketData.top10TotalHoldings")]
        MarketDataTop10TotalHoldings,
        #[serde(rename = "marketData.top10HoldingsRatio")]
        MarketDataTop10HoldingsRatio,
        #[serde(rename = "marketData.top100TotalHoldings")]
        MarketDataTop100TotalHoldings,
        #[serde(rename = "marketData.top100HoldingsRatio")]
        MarketDataTop100HoldingsRatio,
        #[serde(rename = "marketData.holders")]
        MarketDataHolders,
        #[serde(rename = "marketData.creatorHoldings")]
        MarketDataCreatorHoldings,
        #[serde(rename = "marketData.creatorHoldingsRatio")]
        MarketDataCreatorHoldingsRatio,
        #[serde(rename = "stats.buys1m")]
        StatsBuys1m,
        #[serde(rename = "stats.buys5m")]
        StatsBuys5m,
        #[serde(rename = "stats.buys15m")]
        StatsBuys15m,
        #[serde(rename = "stats.buys30m")]
        StatsBuys30m,
        #[serde(rename = "stats.buys1h")]
        StatsBuys1h,
        #[serde(rename = "stats.buys4h")]
        StatsBuys4h,
        #[serde(rename = "stats.buys24h")]
        StatsBuys24h,
        #[serde(rename = "stats.sells1m")]
        StatsSells1m,
        #[serde(rename = "stats.sells5m")]
        StatsSells5m,
        #[serde(rename = "stats.sells15m")]
        StatsSells15m,
        #[serde(rename = "stats.sells30m")]
        StatsSells30m,
        #[serde(rename = "stats.sells1h")]
        StatsSells1h,
        #[serde(rename = "stats.sells4h")]
        StatsSells4h,
        #[serde(rename = "stats.sells24h")]
        StatsSells24h,
        #[serde(rename = "stats.trades1m")]
        StatsTrades1m,
        #[serde(rename = "stats.trades5m")]
        StatsTrades5m,
        #[serde(rename = "stats.trades1h")]
        StatsTrades1h,
        #[serde(rename = "stats.trades4h")]
        StatsTrades4h,
        #[serde(rename = "stats.trades24h")]
        StatsTrades24h,
        #[serde(rename = "stats.traders1m")]
        StatsTraders1m,
        #[serde(rename = "stats.traders5m")]
        StatsTraders5m,
        #[serde(rename = "stats.traders1h")]
        StatsTraders1h,
        #[serde(rename = "stats.traders4h")]
        StatsTraders4h,
        #[serde(rename = "stats.traders24h")]
        StatsTraders24h,
        #[serde(rename = "stats.volumesInUsd1m")]
        StatsVolumesInUsd1m,
        #[serde(rename = "stats.volumesInUsd5m")]
        StatsVolumesInUsd5m,
        #[serde(rename = "stats.volumesInUsd1h")]
        StatsVolumesInUsd1h,
        #[serde(rename = "stats.volumesInUsd4h")]
        StatsVolumesInUsd4h,
        #[serde(rename = "stats.volumesInUsd24h")]
        StatsVolumesInUsd24h,
        #[serde(rename = "tokenCreatedAt")]
        TokenCreatedAt,
    }
    impl ::std::convert::From<&Self> for GetMigratedTokensSortBy {
        fn from(value: &GetMigratedTokensSortBy) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for GetMigratedTokensSortBy {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::MarketDataPriceInUsd => f.write_str("marketData.priceInUsd"),
                Self::StatsPriceChangeRatioInUsd1m => {
                    f.write_str("stats.priceChangeRatioInUsd1m")
                }
                Self::StatsPriceChangeRatioInUsd5m => {
                    f.write_str("stats.priceChangeRatioInUsd5m")
                }
                Self::StatsPriceChangeRatioInUsd1h => {
                    f.write_str("stats.priceChangeRatioInUsd1h")
                }
                Self::StatsPriceChangeRatioInUsd4h => {
                    f.write_str("stats.priceChangeRatioInUsd4h")
                }
                Self::StatsPriceChangeRatioInUsd24h => {
                    f.write_str("stats.priceChangeRatioInUsd24h")
                }
                Self::MarketDataMarketCapInUsd => {
                    f.write_str("marketData.marketCapInUsd")
                }
                Self::MarketDataMaxPoolTvlInUsd => {
                    f.write_str("marketData.maxPoolTvlInUsd")
                }
                Self::MarketDataTotalTvlInUsd => f.write_str("marketData.totalTvlInUsd"),
                Self::MarketDataTop10TotalHoldings => {
                    f.write_str("marketData.top10TotalHoldings")
                }
                Self::MarketDataTop10HoldingsRatio => {
                    f.write_str("marketData.top10HoldingsRatio")
                }
                Self::MarketDataTop100TotalHoldings => {
                    f.write_str("marketData.top100TotalHoldings")
                }
                Self::MarketDataTop100HoldingsRatio => {
                    f.write_str("marketData.top100HoldingsRatio")
                }
                Self::MarketDataHolders => f.write_str("marketData.holders"),
                Self::MarketDataCreatorHoldings => {
                    f.write_str("marketData.creatorHoldings")
                }
                Self::MarketDataCreatorHoldingsRatio => {
                    f.write_str("marketData.creatorHoldingsRatio")
                }
                Self::StatsBuys1m => f.write_str("stats.buys1m"),
                Self::StatsBuys5m => f.write_str("stats.buys5m"),
                Self::StatsBuys15m => f.write_str("stats.buys15m"),
                Self::StatsBuys30m => f.write_str("stats.buys30m"),
                Self::StatsBuys1h => f.write_str("stats.buys1h"),
                Self::StatsBuys4h => f.write_str("stats.buys4h"),
                Self::StatsBuys24h => f.write_str("stats.buys24h"),
                Self::StatsSells1m => f.write_str("stats.sells1m"),
                Self::StatsSells5m => f.write_str("stats.sells5m"),
                Self::StatsSells15m => f.write_str("stats.sells15m"),
                Self::StatsSells30m => f.write_str("stats.sells30m"),
                Self::StatsSells1h => f.write_str("stats.sells1h"),
                Self::StatsSells4h => f.write_str("stats.sells4h"),
                Self::StatsSells24h => f.write_str("stats.sells24h"),
                Self::StatsTrades1m => f.write_str("stats.trades1m"),
                Self::StatsTrades5m => f.write_str("stats.trades5m"),
                Self::StatsTrades1h => f.write_str("stats.trades1h"),
                Self::StatsTrades4h => f.write_str("stats.trades4h"),
                Self::StatsTrades24h => f.write_str("stats.trades24h"),
                Self::StatsTraders1m => f.write_str("stats.traders1m"),
                Self::StatsTraders5m => f.write_str("stats.traders5m"),
                Self::StatsTraders1h => f.write_str("stats.traders1h"),
                Self::StatsTraders4h => f.write_str("stats.traders4h"),
                Self::StatsTraders24h => f.write_str("stats.traders24h"),
                Self::StatsVolumesInUsd1m => f.write_str("stats.volumesInUsd1m"),
                Self::StatsVolumesInUsd5m => f.write_str("stats.volumesInUsd5m"),
                Self::StatsVolumesInUsd1h => f.write_str("stats.volumesInUsd1h"),
                Self::StatsVolumesInUsd4h => f.write_str("stats.volumesInUsd4h"),
                Self::StatsVolumesInUsd24h => f.write_str("stats.volumesInUsd24h"),
                Self::TokenCreatedAt => f.write_str("tokenCreatedAt"),
            }
        }
    }
    impl ::std::str::FromStr for GetMigratedTokensSortBy {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "marketData.priceInUsd" => Ok(Self::MarketDataPriceInUsd),
                "stats.priceChangeRatioInUsd1m" => Ok(Self::StatsPriceChangeRatioInUsd1m),
                "stats.priceChangeRatioInUsd5m" => Ok(Self::StatsPriceChangeRatioInUsd5m),
                "stats.priceChangeRatioInUsd1h" => Ok(Self::StatsPriceChangeRatioInUsd1h),
                "stats.priceChangeRatioInUsd4h" => Ok(Self::StatsPriceChangeRatioInUsd4h),
                "stats.priceChangeRatioInUsd24h" => {
                    Ok(Self::StatsPriceChangeRatioInUsd24h)
                }
                "marketData.marketCapInUsd" => Ok(Self::MarketDataMarketCapInUsd),
                "marketData.maxPoolTvlInUsd" => Ok(Self::MarketDataMaxPoolTvlInUsd),
                "marketData.totalTvlInUsd" => Ok(Self::MarketDataTotalTvlInUsd),
                "marketData.top10TotalHoldings" => Ok(Self::MarketDataTop10TotalHoldings),
                "marketData.top10HoldingsRatio" => Ok(Self::MarketDataTop10HoldingsRatio),
                "marketData.top100TotalHoldings" => {
                    Ok(Self::MarketDataTop100TotalHoldings)
                }
                "marketData.top100HoldingsRatio" => {
                    Ok(Self::MarketDataTop100HoldingsRatio)
                }
                "marketData.holders" => Ok(Self::MarketDataHolders),
                "marketData.creatorHoldings" => Ok(Self::MarketDataCreatorHoldings),
                "marketData.creatorHoldingsRatio" => {
                    Ok(Self::MarketDataCreatorHoldingsRatio)
                }
                "stats.buys1m" => Ok(Self::StatsBuys1m),
                "stats.buys5m" => Ok(Self::StatsBuys5m),
                "stats.buys15m" => Ok(Self::StatsBuys15m),
                "stats.buys30m" => Ok(Self::StatsBuys30m),
                "stats.buys1h" => Ok(Self::StatsBuys1h),
                "stats.buys4h" => Ok(Self::StatsBuys4h),
                "stats.buys24h" => Ok(Self::StatsBuys24h),
                "stats.sells1m" => Ok(Self::StatsSells1m),
                "stats.sells5m" => Ok(Self::StatsSells5m),
                "stats.sells15m" => Ok(Self::StatsSells15m),
                "stats.sells30m" => Ok(Self::StatsSells30m),
                "stats.sells1h" => Ok(Self::StatsSells1h),
                "stats.sells4h" => Ok(Self::StatsSells4h),
                "stats.sells24h" => Ok(Self::StatsSells24h),
                "stats.trades1m" => Ok(Self::StatsTrades1m),
                "stats.trades5m" => Ok(Self::StatsTrades5m),
                "stats.trades1h" => Ok(Self::StatsTrades1h),
                "stats.trades4h" => Ok(Self::StatsTrades4h),
                "stats.trades24h" => Ok(Self::StatsTrades24h),
                "stats.traders1m" => Ok(Self::StatsTraders1m),
                "stats.traders5m" => Ok(Self::StatsTraders5m),
                "stats.traders1h" => Ok(Self::StatsTraders1h),
                "stats.traders4h" => Ok(Self::StatsTraders4h),
                "stats.traders24h" => Ok(Self::StatsTraders24h),
                "stats.volumesInUsd1m" => Ok(Self::StatsVolumesInUsd1m),
                "stats.volumesInUsd5m" => Ok(Self::StatsVolumesInUsd5m),
                "stats.volumesInUsd1h" => Ok(Self::StatsVolumesInUsd1h),
                "stats.volumesInUsd4h" => Ok(Self::StatsVolumesInUsd4h),
                "stats.volumesInUsd24h" => Ok(Self::StatsVolumesInUsd24h),
                "tokenCreatedAt" => Ok(Self::TokenCreatedAt),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for GetMigratedTokensSortBy {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String> for GetMigratedTokensSortBy {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for GetMigratedTokensSortBy {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    ///`GetMigratedTokensSortDirection`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "default": "DESC",
    ///  "type": "string",
    ///  "enum": [
    ///    "ASC",
    ///    "DESC"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum GetMigratedTokensSortDirection {
        #[serde(rename = "ASC")]
        Asc,
        #[serde(rename = "DESC")]
        Desc,
    }
    impl ::std::convert::From<&Self> for GetMigratedTokensSortDirection {
        fn from(value: &GetMigratedTokensSortDirection) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for GetMigratedTokensSortDirection {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::Asc => f.write_str("ASC"),
                Self::Desc => f.write_str("DESC"),
            }
        }
    }
    impl ::std::str::FromStr for GetMigratedTokensSortDirection {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "ASC" => Ok(Self::Asc),
                "DESC" => Ok(Self::Desc),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for GetMigratedTokensSortDirection {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String>
    for GetMigratedTokensSortDirection {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String>
    for GetMigratedTokensSortDirection {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::default::Default for GetMigratedTokensSortDirection {
        fn default() -> Self {
            GetMigratedTokensSortDirection::Desc
        }
    }
    ///`GetMigratedTokensTag`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "string",
    ///  "enum": [
    ///    "pump_fun",
    ///    "raydium_launchpad",
    ///    "meteora_dynamic_bounding_curve",
    ///    "bonk_fun",
    ///    "moonit_fun"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum GetMigratedTokensTag {
        #[serde(rename = "pump_fun")]
        PumpFun,
        #[serde(rename = "raydium_launchpad")]
        RaydiumLaunchpad,
        #[serde(rename = "meteora_dynamic_bounding_curve")]
        MeteoraDynamicBoundingCurve,
        #[serde(rename = "bonk_fun")]
        BonkFun,
        #[serde(rename = "moonit_fun")]
        MoonitFun,
    }
    impl ::std::convert::From<&Self> for GetMigratedTokensTag {
        fn from(value: &GetMigratedTokensTag) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for GetMigratedTokensTag {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::PumpFun => f.write_str("pump_fun"),
                Self::RaydiumLaunchpad => f.write_str("raydium_launchpad"),
                Self::MeteoraDynamicBoundingCurve => {
                    f.write_str("meteora_dynamic_bounding_curve")
                }
                Self::BonkFun => f.write_str("bonk_fun"),
                Self::MoonitFun => f.write_str("moonit_fun"),
            }
        }
    }
    impl ::std::str::FromStr for GetMigratedTokensTag {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "pump_fun" => Ok(Self::PumpFun),
                "raydium_launchpad" => Ok(Self::RaydiumLaunchpad),
                "meteora_dynamic_bounding_curve" => Ok(Self::MeteoraDynamicBoundingCurve),
                "bonk_fun" => Ok(Self::BonkFun),
                "moonit_fun" => Ok(Self::MoonitFun),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for GetMigratedTokensTag {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String> for GetMigratedTokensTag {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for GetMigratedTokensTag {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    ///`GetMintAndBurnDirection`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "default": "next",
    ///  "type": "string",
    ///  "enum": [
    ///    "next",
    ///    "prev"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum GetMintAndBurnDirection {
        #[serde(rename = "next")]
        Next,
        #[serde(rename = "prev")]
        Prev,
    }
    impl ::std::convert::From<&Self> for GetMintAndBurnDirection {
        fn from(value: &GetMintAndBurnDirection) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for GetMintAndBurnDirection {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::Next => f.write_str("next"),
                Self::Prev => f.write_str("prev"),
            }
        }
    }
    impl ::std::str::FromStr for GetMintAndBurnDirection {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "next" => Ok(Self::Next),
                "prev" => Ok(Self::Prev),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for GetMintAndBurnDirection {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String> for GetMintAndBurnDirection {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for GetMintAndBurnDirection {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::default::Default for GetMintAndBurnDirection {
        fn default() -> Self {
            GetMintAndBurnDirection::Next
        }
    }
    ///`GetMintAndBurnType`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "default": "all",
    ///  "examples": [
    ///    "all"
    ///  ],
    ///  "type": "string",
    ///  "enum": [
    ///    "all",
    ///    "mint",
    ///    "burn"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum GetMintAndBurnType {
        #[serde(rename = "all")]
        All,
        #[serde(rename = "mint")]
        Mint,
        #[serde(rename = "burn")]
        Burn,
    }
    impl ::std::convert::From<&Self> for GetMintAndBurnType {
        fn from(value: &GetMintAndBurnType) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for GetMintAndBurnType {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::All => f.write_str("all"),
                Self::Mint => f.write_str("mint"),
                Self::Burn => f.write_str("burn"),
            }
        }
    }
    impl ::std::str::FromStr for GetMintAndBurnType {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "all" => Ok(Self::All),
                "mint" => Ok(Self::Mint),
                "burn" => Ok(Self::Burn),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for GetMintAndBurnType {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String> for GetMintAndBurnType {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for GetMintAndBurnType {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::default::Default for GetMintAndBurnType {
        fn default() -> Self {
            GetMintAndBurnType::All
        }
    }
    ///`GetNetWorthDetailsDirection`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "default": "next",
    ///  "type": "string",
    ///  "enum": [
    ///    "next",
    ///    "prev"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum GetNetWorthDetailsDirection {
        #[serde(rename = "next")]
        Next,
        #[serde(rename = "prev")]
        Prev,
    }
    impl ::std::convert::From<&Self> for GetNetWorthDetailsDirection {
        fn from(value: &GetNetWorthDetailsDirection) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for GetNetWorthDetailsDirection {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::Next => f.write_str("next"),
                Self::Prev => f.write_str("prev"),
            }
        }
    }
    impl ::std::str::FromStr for GetNetWorthDetailsDirection {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "next" => Ok(Self::Next),
                "prev" => Ok(Self::Prev),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for GetNetWorthDetailsDirection {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String>
    for GetNetWorthDetailsDirection {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for GetNetWorthDetailsDirection {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::default::Default for GetNetWorthDetailsDirection {
        fn default() -> Self {
            GetNetWorthDetailsDirection::Next
        }
    }
    ///`GetNetWorthDirection`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "default": "next",
    ///  "type": "string",
    ///  "enum": [
    ///    "next",
    ///    "prev"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum GetNetWorthDirection {
        #[serde(rename = "next")]
        Next,
        #[serde(rename = "prev")]
        Prev,
    }
    impl ::std::convert::From<&Self> for GetNetWorthDirection {
        fn from(value: &GetNetWorthDirection) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for GetNetWorthDirection {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::Next => f.write_str("next"),
                Self::Prev => f.write_str("prev"),
            }
        }
    }
    impl ::std::str::FromStr for GetNetWorthDirection {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "next" => Ok(Self::Next),
                "prev" => Ok(Self::Prev),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for GetNetWorthDirection {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String> for GetNetWorthDirection {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for GetNetWorthDirection {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::default::Default for GetNetWorthDirection {
        fn default() -> Self {
            GetNetWorthDirection::Next
        }
    }
    ///`GetNewTokensSortBy`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "examples": [
    ///    "marketData.marketCapInUsd"
    ///  ],
    ///  "type": "string",
    ///  "enum": [
    ///    "marketData.priceInUsd",
    ///    "stats.priceChangeRatioInUsd1m",
    ///    "stats.priceChangeRatioInUsd5m",
    ///    "stats.priceChangeRatioInUsd1h",
    ///    "stats.priceChangeRatioInUsd4h",
    ///    "stats.priceChangeRatioInUsd24h",
    ///    "marketData.marketCapInUsd",
    ///    "marketData.maxPoolTvlInUsd",
    ///    "marketData.totalTvlInUsd",
    ///    "marketData.top10TotalHoldings",
    ///    "marketData.top10HoldingsRatio",
    ///    "marketData.top100TotalHoldings",
    ///    "marketData.top100HoldingsRatio",
    ///    "marketData.holders",
    ///    "marketData.creatorHoldings",
    ///    "marketData.creatorHoldingsRatio",
    ///    "stats.buys1m",
    ///    "stats.buys5m",
    ///    "stats.buys15m",
    ///    "stats.buys30m",
    ///    "stats.buys1h",
    ///    "stats.buys4h",
    ///    "stats.buys24h",
    ///    "stats.sells1m",
    ///    "stats.sells5m",
    ///    "stats.sells15m",
    ///    "stats.sells30m",
    ///    "stats.sells1h",
    ///    "stats.sells4h",
    ///    "stats.sells24h",
    ///    "stats.trades1m",
    ///    "stats.trades5m",
    ///    "stats.trades1h",
    ///    "stats.trades4h",
    ///    "stats.trades24h",
    ///    "stats.traders1m",
    ///    "stats.traders5m",
    ///    "stats.traders1h",
    ///    "stats.traders4h",
    ///    "stats.traders24h",
    ///    "stats.volumesInUsd1m",
    ///    "stats.volumesInUsd5m",
    ///    "stats.volumesInUsd1h",
    ///    "stats.volumesInUsd4h",
    ///    "stats.volumesInUsd24h",
    ///    "tokenCreatedAt"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum GetNewTokensSortBy {
        #[serde(rename = "marketData.priceInUsd")]
        MarketDataPriceInUsd,
        #[serde(rename = "stats.priceChangeRatioInUsd1m")]
        StatsPriceChangeRatioInUsd1m,
        #[serde(rename = "stats.priceChangeRatioInUsd5m")]
        StatsPriceChangeRatioInUsd5m,
        #[serde(rename = "stats.priceChangeRatioInUsd1h")]
        StatsPriceChangeRatioInUsd1h,
        #[serde(rename = "stats.priceChangeRatioInUsd4h")]
        StatsPriceChangeRatioInUsd4h,
        #[serde(rename = "stats.priceChangeRatioInUsd24h")]
        StatsPriceChangeRatioInUsd24h,
        #[serde(rename = "marketData.marketCapInUsd")]
        MarketDataMarketCapInUsd,
        #[serde(rename = "marketData.maxPoolTvlInUsd")]
        MarketDataMaxPoolTvlInUsd,
        #[serde(rename = "marketData.totalTvlInUsd")]
        MarketDataTotalTvlInUsd,
        #[serde(rename = "marketData.top10TotalHoldings")]
        MarketDataTop10TotalHoldings,
        #[serde(rename = "marketData.top10HoldingsRatio")]
        MarketDataTop10HoldingsRatio,
        #[serde(rename = "marketData.top100TotalHoldings")]
        MarketDataTop100TotalHoldings,
        #[serde(rename = "marketData.top100HoldingsRatio")]
        MarketDataTop100HoldingsRatio,
        #[serde(rename = "marketData.holders")]
        MarketDataHolders,
        #[serde(rename = "marketData.creatorHoldings")]
        MarketDataCreatorHoldings,
        #[serde(rename = "marketData.creatorHoldingsRatio")]
        MarketDataCreatorHoldingsRatio,
        #[serde(rename = "stats.buys1m")]
        StatsBuys1m,
        #[serde(rename = "stats.buys5m")]
        StatsBuys5m,
        #[serde(rename = "stats.buys15m")]
        StatsBuys15m,
        #[serde(rename = "stats.buys30m")]
        StatsBuys30m,
        #[serde(rename = "stats.buys1h")]
        StatsBuys1h,
        #[serde(rename = "stats.buys4h")]
        StatsBuys4h,
        #[serde(rename = "stats.buys24h")]
        StatsBuys24h,
        #[serde(rename = "stats.sells1m")]
        StatsSells1m,
        #[serde(rename = "stats.sells5m")]
        StatsSells5m,
        #[serde(rename = "stats.sells15m")]
        StatsSells15m,
        #[serde(rename = "stats.sells30m")]
        StatsSells30m,
        #[serde(rename = "stats.sells1h")]
        StatsSells1h,
        #[serde(rename = "stats.sells4h")]
        StatsSells4h,
        #[serde(rename = "stats.sells24h")]
        StatsSells24h,
        #[serde(rename = "stats.trades1m")]
        StatsTrades1m,
        #[serde(rename = "stats.trades5m")]
        StatsTrades5m,
        #[serde(rename = "stats.trades1h")]
        StatsTrades1h,
        #[serde(rename = "stats.trades4h")]
        StatsTrades4h,
        #[serde(rename = "stats.trades24h")]
        StatsTrades24h,
        #[serde(rename = "stats.traders1m")]
        StatsTraders1m,
        #[serde(rename = "stats.traders5m")]
        StatsTraders5m,
        #[serde(rename = "stats.traders1h")]
        StatsTraders1h,
        #[serde(rename = "stats.traders4h")]
        StatsTraders4h,
        #[serde(rename = "stats.traders24h")]
        StatsTraders24h,
        #[serde(rename = "stats.volumesInUsd1m")]
        StatsVolumesInUsd1m,
        #[serde(rename = "stats.volumesInUsd5m")]
        StatsVolumesInUsd5m,
        #[serde(rename = "stats.volumesInUsd1h")]
        StatsVolumesInUsd1h,
        #[serde(rename = "stats.volumesInUsd4h")]
        StatsVolumesInUsd4h,
        #[serde(rename = "stats.volumesInUsd24h")]
        StatsVolumesInUsd24h,
        #[serde(rename = "tokenCreatedAt")]
        TokenCreatedAt,
    }
    impl ::std::convert::From<&Self> for GetNewTokensSortBy {
        fn from(value: &GetNewTokensSortBy) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for GetNewTokensSortBy {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::MarketDataPriceInUsd => f.write_str("marketData.priceInUsd"),
                Self::StatsPriceChangeRatioInUsd1m => {
                    f.write_str("stats.priceChangeRatioInUsd1m")
                }
                Self::StatsPriceChangeRatioInUsd5m => {
                    f.write_str("stats.priceChangeRatioInUsd5m")
                }
                Self::StatsPriceChangeRatioInUsd1h => {
                    f.write_str("stats.priceChangeRatioInUsd1h")
                }
                Self::StatsPriceChangeRatioInUsd4h => {
                    f.write_str("stats.priceChangeRatioInUsd4h")
                }
                Self::StatsPriceChangeRatioInUsd24h => {
                    f.write_str("stats.priceChangeRatioInUsd24h")
                }
                Self::MarketDataMarketCapInUsd => {
                    f.write_str("marketData.marketCapInUsd")
                }
                Self::MarketDataMaxPoolTvlInUsd => {
                    f.write_str("marketData.maxPoolTvlInUsd")
                }
                Self::MarketDataTotalTvlInUsd => f.write_str("marketData.totalTvlInUsd"),
                Self::MarketDataTop10TotalHoldings => {
                    f.write_str("marketData.top10TotalHoldings")
                }
                Self::MarketDataTop10HoldingsRatio => {
                    f.write_str("marketData.top10HoldingsRatio")
                }
                Self::MarketDataTop100TotalHoldings => {
                    f.write_str("marketData.top100TotalHoldings")
                }
                Self::MarketDataTop100HoldingsRatio => {
                    f.write_str("marketData.top100HoldingsRatio")
                }
                Self::MarketDataHolders => f.write_str("marketData.holders"),
                Self::MarketDataCreatorHoldings => {
                    f.write_str("marketData.creatorHoldings")
                }
                Self::MarketDataCreatorHoldingsRatio => {
                    f.write_str("marketData.creatorHoldingsRatio")
                }
                Self::StatsBuys1m => f.write_str("stats.buys1m"),
                Self::StatsBuys5m => f.write_str("stats.buys5m"),
                Self::StatsBuys15m => f.write_str("stats.buys15m"),
                Self::StatsBuys30m => f.write_str("stats.buys30m"),
                Self::StatsBuys1h => f.write_str("stats.buys1h"),
                Self::StatsBuys4h => f.write_str("stats.buys4h"),
                Self::StatsBuys24h => f.write_str("stats.buys24h"),
                Self::StatsSells1m => f.write_str("stats.sells1m"),
                Self::StatsSells5m => f.write_str("stats.sells5m"),
                Self::StatsSells15m => f.write_str("stats.sells15m"),
                Self::StatsSells30m => f.write_str("stats.sells30m"),
                Self::StatsSells1h => f.write_str("stats.sells1h"),
                Self::StatsSells4h => f.write_str("stats.sells4h"),
                Self::StatsSells24h => f.write_str("stats.sells24h"),
                Self::StatsTrades1m => f.write_str("stats.trades1m"),
                Self::StatsTrades5m => f.write_str("stats.trades5m"),
                Self::StatsTrades1h => f.write_str("stats.trades1h"),
                Self::StatsTrades4h => f.write_str("stats.trades4h"),
                Self::StatsTrades24h => f.write_str("stats.trades24h"),
                Self::StatsTraders1m => f.write_str("stats.traders1m"),
                Self::StatsTraders5m => f.write_str("stats.traders5m"),
                Self::StatsTraders1h => f.write_str("stats.traders1h"),
                Self::StatsTraders4h => f.write_str("stats.traders4h"),
                Self::StatsTraders24h => f.write_str("stats.traders24h"),
                Self::StatsVolumesInUsd1m => f.write_str("stats.volumesInUsd1m"),
                Self::StatsVolumesInUsd5m => f.write_str("stats.volumesInUsd5m"),
                Self::StatsVolumesInUsd1h => f.write_str("stats.volumesInUsd1h"),
                Self::StatsVolumesInUsd4h => f.write_str("stats.volumesInUsd4h"),
                Self::StatsVolumesInUsd24h => f.write_str("stats.volumesInUsd24h"),
                Self::TokenCreatedAt => f.write_str("tokenCreatedAt"),
            }
        }
    }
    impl ::std::str::FromStr for GetNewTokensSortBy {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "marketData.priceInUsd" => Ok(Self::MarketDataPriceInUsd),
                "stats.priceChangeRatioInUsd1m" => Ok(Self::StatsPriceChangeRatioInUsd1m),
                "stats.priceChangeRatioInUsd5m" => Ok(Self::StatsPriceChangeRatioInUsd5m),
                "stats.priceChangeRatioInUsd1h" => Ok(Self::StatsPriceChangeRatioInUsd1h),
                "stats.priceChangeRatioInUsd4h" => Ok(Self::StatsPriceChangeRatioInUsd4h),
                "stats.priceChangeRatioInUsd24h" => {
                    Ok(Self::StatsPriceChangeRatioInUsd24h)
                }
                "marketData.marketCapInUsd" => Ok(Self::MarketDataMarketCapInUsd),
                "marketData.maxPoolTvlInUsd" => Ok(Self::MarketDataMaxPoolTvlInUsd),
                "marketData.totalTvlInUsd" => Ok(Self::MarketDataTotalTvlInUsd),
                "marketData.top10TotalHoldings" => Ok(Self::MarketDataTop10TotalHoldings),
                "marketData.top10HoldingsRatio" => Ok(Self::MarketDataTop10HoldingsRatio),
                "marketData.top100TotalHoldings" => {
                    Ok(Self::MarketDataTop100TotalHoldings)
                }
                "marketData.top100HoldingsRatio" => {
                    Ok(Self::MarketDataTop100HoldingsRatio)
                }
                "marketData.holders" => Ok(Self::MarketDataHolders),
                "marketData.creatorHoldings" => Ok(Self::MarketDataCreatorHoldings),
                "marketData.creatorHoldingsRatio" => {
                    Ok(Self::MarketDataCreatorHoldingsRatio)
                }
                "stats.buys1m" => Ok(Self::StatsBuys1m),
                "stats.buys5m" => Ok(Self::StatsBuys5m),
                "stats.buys15m" => Ok(Self::StatsBuys15m),
                "stats.buys30m" => Ok(Self::StatsBuys30m),
                "stats.buys1h" => Ok(Self::StatsBuys1h),
                "stats.buys4h" => Ok(Self::StatsBuys4h),
                "stats.buys24h" => Ok(Self::StatsBuys24h),
                "stats.sells1m" => Ok(Self::StatsSells1m),
                "stats.sells5m" => Ok(Self::StatsSells5m),
                "stats.sells15m" => Ok(Self::StatsSells15m),
                "stats.sells30m" => Ok(Self::StatsSells30m),
                "stats.sells1h" => Ok(Self::StatsSells1h),
                "stats.sells4h" => Ok(Self::StatsSells4h),
                "stats.sells24h" => Ok(Self::StatsSells24h),
                "stats.trades1m" => Ok(Self::StatsTrades1m),
                "stats.trades5m" => Ok(Self::StatsTrades5m),
                "stats.trades1h" => Ok(Self::StatsTrades1h),
                "stats.trades4h" => Ok(Self::StatsTrades4h),
                "stats.trades24h" => Ok(Self::StatsTrades24h),
                "stats.traders1m" => Ok(Self::StatsTraders1m),
                "stats.traders5m" => Ok(Self::StatsTraders5m),
                "stats.traders1h" => Ok(Self::StatsTraders1h),
                "stats.traders4h" => Ok(Self::StatsTraders4h),
                "stats.traders24h" => Ok(Self::StatsTraders24h),
                "stats.volumesInUsd1m" => Ok(Self::StatsVolumesInUsd1m),
                "stats.volumesInUsd5m" => Ok(Self::StatsVolumesInUsd5m),
                "stats.volumesInUsd1h" => Ok(Self::StatsVolumesInUsd1h),
                "stats.volumesInUsd4h" => Ok(Self::StatsVolumesInUsd4h),
                "stats.volumesInUsd24h" => Ok(Self::StatsVolumesInUsd24h),
                "tokenCreatedAt" => Ok(Self::TokenCreatedAt),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for GetNewTokensSortBy {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String> for GetNewTokensSortBy {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for GetNewTokensSortBy {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    ///`GetNewTokensSortDirection`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "default": "DESC",
    ///  "type": "string",
    ///  "enum": [
    ///    "ASC",
    ///    "DESC"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum GetNewTokensSortDirection {
        #[serde(rename = "ASC")]
        Asc,
        #[serde(rename = "DESC")]
        Desc,
    }
    impl ::std::convert::From<&Self> for GetNewTokensSortDirection {
        fn from(value: &GetNewTokensSortDirection) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for GetNewTokensSortDirection {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::Asc => f.write_str("ASC"),
                Self::Desc => f.write_str("DESC"),
            }
        }
    }
    impl ::std::str::FromStr for GetNewTokensSortDirection {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "ASC" => Ok(Self::Asc),
                "DESC" => Ok(Self::Desc),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for GetNewTokensSortDirection {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String> for GetNewTokensSortDirection {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for GetNewTokensSortDirection {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::default::Default for GetNewTokensSortDirection {
        fn default() -> Self {
            GetNewTokensSortDirection::Desc
        }
    }
    ///`GetNewTokensTag`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "string",
    ///  "enum": [
    ///    "pump_fun",
    ///    "raydium_launchpad",
    ///    "meteora_dynamic_bounding_curve",
    ///    "bonk_fun",
    ///    "moonit_fun"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum GetNewTokensTag {
        #[serde(rename = "pump_fun")]
        PumpFun,
        #[serde(rename = "raydium_launchpad")]
        RaydiumLaunchpad,
        #[serde(rename = "meteora_dynamic_bounding_curve")]
        MeteoraDynamicBoundingCurve,
        #[serde(rename = "bonk_fun")]
        BonkFun,
        #[serde(rename = "moonit_fun")]
        MoonitFun,
    }
    impl ::std::convert::From<&Self> for GetNewTokensTag {
        fn from(value: &GetNewTokensTag) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for GetNewTokensTag {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::PumpFun => f.write_str("pump_fun"),
                Self::RaydiumLaunchpad => f.write_str("raydium_launchpad"),
                Self::MeteoraDynamicBoundingCurve => {
                    f.write_str("meteora_dynamic_bounding_curve")
                }
                Self::BonkFun => f.write_str("bonk_fun"),
                Self::MoonitFun => f.write_str("moonit_fun"),
            }
        }
    }
    impl ::std::str::FromStr for GetNewTokensTag {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "pump_fun" => Ok(Self::PumpFun),
                "raydium_launchpad" => Ok(Self::RaydiumLaunchpad),
                "meteora_dynamic_bounding_curve" => Ok(Self::MeteoraDynamicBoundingCurve),
                "bonk_fun" => Ok(Self::BonkFun),
                "moonit_fun" => Ok(Self::MoonitFun),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for GetNewTokensTag {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String> for GetNewTokensTag {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for GetNewTokensTag {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    ///`GetPnlByTokenDirection`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "default": "next",
    ///  "type": "string",
    ///  "enum": [
    ///    "next",
    ///    "prev"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum GetPnlByTokenDirection {
        #[serde(rename = "next")]
        Next,
        #[serde(rename = "prev")]
        Prev,
    }
    impl ::std::convert::From<&Self> for GetPnlByTokenDirection {
        fn from(value: &GetPnlByTokenDirection) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for GetPnlByTokenDirection {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::Next => f.write_str("next"),
                Self::Prev => f.write_str("prev"),
            }
        }
    }
    impl ::std::str::FromStr for GetPnlByTokenDirection {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "next" => Ok(Self::Next),
                "prev" => Ok(Self::Prev),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for GetPnlByTokenDirection {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String> for GetPnlByTokenDirection {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for GetPnlByTokenDirection {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::default::Default for GetPnlByTokenDirection {
        fn default() -> Self {
            GetPnlByTokenDirection::Next
        }
    }
    ///`GetPnlByWalletDirection`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "default": "next",
    ///  "type": "string",
    ///  "enum": [
    ///    "next",
    ///    "prev"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum GetPnlByWalletDirection {
        #[serde(rename = "next")]
        Next,
        #[serde(rename = "prev")]
        Prev,
    }
    impl ::std::convert::From<&Self> for GetPnlByWalletDirection {
        fn from(value: &GetPnlByWalletDirection) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for GetPnlByWalletDirection {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::Next => f.write_str("next"),
                Self::Prev => f.write_str("prev"),
            }
        }
    }
    impl ::std::str::FromStr for GetPnlByWalletDirection {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "next" => Ok(Self::Next),
                "prev" => Ok(Self::Prev),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for GetPnlByWalletDirection {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String> for GetPnlByWalletDirection {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for GetPnlByWalletDirection {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::default::Default for GetPnlByWalletDirection {
        fn default() -> Self {
            GetPnlByWalletDirection::Next
        }
    }
    ///`GetPnlDetailsDirection`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "default": "next",
    ///  "type": "string",
    ///  "enum": [
    ///    "next",
    ///    "prev"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum GetPnlDetailsDirection {
        #[serde(rename = "next")]
        Next,
        #[serde(rename = "prev")]
        Prev,
    }
    impl ::std::convert::From<&Self> for GetPnlDetailsDirection {
        fn from(value: &GetPnlDetailsDirection) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for GetPnlDetailsDirection {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::Next => f.write_str("next"),
                Self::Prev => f.write_str("prev"),
            }
        }
    }
    impl ::std::str::FromStr for GetPnlDetailsDirection {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "next" => Ok(Self::Next),
                "prev" => Ok(Self::Prev),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for GetPnlDetailsDirection {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String> for GetPnlDetailsDirection {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for GetPnlDetailsDirection {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::default::Default for GetPnlDetailsDirection {
        fn default() -> Self {
            GetPnlDetailsDirection::Next
        }
    }
    ///`GetPoolsDirection`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "default": "next",
    ///  "type": "string",
    ///  "enum": [
    ///    "next",
    ///    "prev"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum GetPoolsDirection {
        #[serde(rename = "next")]
        Next,
        #[serde(rename = "prev")]
        Prev,
    }
    impl ::std::convert::From<&Self> for GetPoolsDirection {
        fn from(value: &GetPoolsDirection) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for GetPoolsDirection {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::Next => f.write_str("next"),
                Self::Prev => f.write_str("prev"),
            }
        }
    }
    impl ::std::str::FromStr for GetPoolsDirection {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "next" => Ok(Self::Next),
                "prev" => Ok(Self::Prev),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for GetPoolsDirection {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String> for GetPoolsDirection {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for GetPoolsDirection {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::default::Default for GetPoolsDirection {
        fn default() -> Self {
            GetPoolsDirection::Next
        }
    }
    ///`GetPoolsSortBy`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "default": "tvlInUsd",
    ///  "examples": [
    ///    "tvlInUsd"
    ///  ],
    ///  "type": "string",
    ///  "enum": [
    ///    "tvlInSol",
    ///    "tvlInUsd"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum GetPoolsSortBy {
        #[serde(rename = "tvlInSol")]
        TvlInSol,
        #[serde(rename = "tvlInUsd")]
        TvlInUsd,
    }
    impl ::std::convert::From<&Self> for GetPoolsSortBy {
        fn from(value: &GetPoolsSortBy) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for GetPoolsSortBy {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::TvlInSol => f.write_str("tvlInSol"),
                Self::TvlInUsd => f.write_str("tvlInUsd"),
            }
        }
    }
    impl ::std::str::FromStr for GetPoolsSortBy {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "tvlInSol" => Ok(Self::TvlInSol),
                "tvlInUsd" => Ok(Self::TvlInUsd),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for GetPoolsSortBy {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String> for GetPoolsSortBy {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for GetPoolsSortBy {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::default::Default for GetPoolsSortBy {
        fn default() -> Self {
            GetPoolsSortBy::TvlInUsd
        }
    }
    ///`GetPoolsSortDirection`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "default": "desc",
    ///  "type": "string",
    ///  "enum": [
    ///    "asc",
    ///    "desc"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum GetPoolsSortDirection {
        #[serde(rename = "asc")]
        Asc,
        #[serde(rename = "desc")]
        Desc,
    }
    impl ::std::convert::From<&Self> for GetPoolsSortDirection {
        fn from(value: &GetPoolsSortDirection) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for GetPoolsSortDirection {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::Asc => f.write_str("asc"),
                Self::Desc => f.write_str("desc"),
            }
        }
    }
    impl ::std::str::FromStr for GetPoolsSortDirection {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "asc" => Ok(Self::Asc),
                "desc" => Ok(Self::Desc),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for GetPoolsSortDirection {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String> for GetPoolsSortDirection {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for GetPoolsSortDirection {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::default::Default for GetPoolsSortDirection {
        fn default() -> Self {
            GetPoolsSortDirection::Desc
        }
    }
    ///`GetPricesDirection`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "default": "next",
    ///  "type": "string",
    ///  "enum": [
    ///    "next",
    ///    "prev"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum GetPricesDirection {
        #[serde(rename = "next")]
        Next,
        #[serde(rename = "prev")]
        Prev,
    }
    impl ::std::convert::From<&Self> for GetPricesDirection {
        fn from(value: &GetPricesDirection) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for GetPricesDirection {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::Next => f.write_str("next"),
                Self::Prev => f.write_str("prev"),
            }
        }
    }
    impl ::std::str::FromStr for GetPricesDirection {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "next" => Ok(Self::Next),
                "prev" => Ok(Self::Prev),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for GetPricesDirection {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String> for GetPricesDirection {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for GetPricesDirection {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::default::Default for GetPricesDirection {
        fn default() -> Self {
            GetPricesDirection::Next
        }
    }
    ///`GetRedpacketsChain`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "examples": [
    ///    "sol"
    ///  ],
    ///  "type": "string",
    ///  "enum": [
    ///    "sol",
    ///    "bsc",
    ///    "eth"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum GetRedpacketsChain {
        #[serde(rename = "sol")]
        Sol,
        #[serde(rename = "bsc")]
        Bsc,
        #[serde(rename = "eth")]
        Eth,
    }
    impl ::std::convert::From<&Self> for GetRedpacketsChain {
        fn from(value: &GetRedpacketsChain) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for GetRedpacketsChain {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::Sol => f.write_str("sol"),
                Self::Bsc => f.write_str("bsc"),
                Self::Eth => f.write_str("eth"),
            }
        }
    }
    impl ::std::str::FromStr for GetRedpacketsChain {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "sol" => Ok(Self::Sol),
                "bsc" => Ok(Self::Bsc),
                "eth" => Ok(Self::Eth),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for GetRedpacketsChain {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String> for GetRedpacketsChain {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for GetRedpacketsChain {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    ///`GetStocksTokensSortBy`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "examples": [
    ///    "marketData.marketCapInUsd"
    ///  ],
    ///  "type": "string",
    ///  "enum": [
    ///    "marketData.priceInUsd",
    ///    "stats.priceChangeRatioInUsd1m",
    ///    "stats.priceChangeRatioInUsd5m",
    ///    "stats.priceChangeRatioInUsd1h",
    ///    "stats.priceChangeRatioInUsd4h",
    ///    "stats.priceChangeRatioInUsd24h",
    ///    "marketData.marketCapInUsd",
    ///    "marketData.maxPoolTvlInUsd",
    ///    "marketData.totalTvlInUsd",
    ///    "marketData.top10TotalHoldings",
    ///    "marketData.top10HoldingsRatio",
    ///    "marketData.top100TotalHoldings",
    ///    "marketData.top100HoldingsRatio",
    ///    "marketData.holders",
    ///    "marketData.creatorHoldings",
    ///    "marketData.creatorHoldingsRatio",
    ///    "stats.buys1m",
    ///    "stats.buys5m",
    ///    "stats.buys15m",
    ///    "stats.buys30m",
    ///    "stats.buys1h",
    ///    "stats.buys4h",
    ///    "stats.buys24h",
    ///    "stats.sells1m",
    ///    "stats.sells5m",
    ///    "stats.sells15m",
    ///    "stats.sells30m",
    ///    "stats.sells1h",
    ///    "stats.sells4h",
    ///    "stats.sells24h",
    ///    "stats.trades1m",
    ///    "stats.trades5m",
    ///    "stats.trades1h",
    ///    "stats.trades4h",
    ///    "stats.trades24h",
    ///    "stats.traders1m",
    ///    "stats.traders5m",
    ///    "stats.traders1h",
    ///    "stats.traders4h",
    ///    "stats.traders24h",
    ///    "stats.volumesInUsd1m",
    ///    "stats.volumesInUsd5m",
    ///    "stats.volumesInUsd1h",
    ///    "stats.volumesInUsd4h",
    ///    "stats.volumesInUsd24h",
    ///    "tokenCreatedAt"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum GetStocksTokensSortBy {
        #[serde(rename = "marketData.priceInUsd")]
        MarketDataPriceInUsd,
        #[serde(rename = "stats.priceChangeRatioInUsd1m")]
        StatsPriceChangeRatioInUsd1m,
        #[serde(rename = "stats.priceChangeRatioInUsd5m")]
        StatsPriceChangeRatioInUsd5m,
        #[serde(rename = "stats.priceChangeRatioInUsd1h")]
        StatsPriceChangeRatioInUsd1h,
        #[serde(rename = "stats.priceChangeRatioInUsd4h")]
        StatsPriceChangeRatioInUsd4h,
        #[serde(rename = "stats.priceChangeRatioInUsd24h")]
        StatsPriceChangeRatioInUsd24h,
        #[serde(rename = "marketData.marketCapInUsd")]
        MarketDataMarketCapInUsd,
        #[serde(rename = "marketData.maxPoolTvlInUsd")]
        MarketDataMaxPoolTvlInUsd,
        #[serde(rename = "marketData.totalTvlInUsd")]
        MarketDataTotalTvlInUsd,
        #[serde(rename = "marketData.top10TotalHoldings")]
        MarketDataTop10TotalHoldings,
        #[serde(rename = "marketData.top10HoldingsRatio")]
        MarketDataTop10HoldingsRatio,
        #[serde(rename = "marketData.top100TotalHoldings")]
        MarketDataTop100TotalHoldings,
        #[serde(rename = "marketData.top100HoldingsRatio")]
        MarketDataTop100HoldingsRatio,
        #[serde(rename = "marketData.holders")]
        MarketDataHolders,
        #[serde(rename = "marketData.creatorHoldings")]
        MarketDataCreatorHoldings,
        #[serde(rename = "marketData.creatorHoldingsRatio")]
        MarketDataCreatorHoldingsRatio,
        #[serde(rename = "stats.buys1m")]
        StatsBuys1m,
        #[serde(rename = "stats.buys5m")]
        StatsBuys5m,
        #[serde(rename = "stats.buys15m")]
        StatsBuys15m,
        #[serde(rename = "stats.buys30m")]
        StatsBuys30m,
        #[serde(rename = "stats.buys1h")]
        StatsBuys1h,
        #[serde(rename = "stats.buys4h")]
        StatsBuys4h,
        #[serde(rename = "stats.buys24h")]
        StatsBuys24h,
        #[serde(rename = "stats.sells1m")]
        StatsSells1m,
        #[serde(rename = "stats.sells5m")]
        StatsSells5m,
        #[serde(rename = "stats.sells15m")]
        StatsSells15m,
        #[serde(rename = "stats.sells30m")]
        StatsSells30m,
        #[serde(rename = "stats.sells1h")]
        StatsSells1h,
        #[serde(rename = "stats.sells4h")]
        StatsSells4h,
        #[serde(rename = "stats.sells24h")]
        StatsSells24h,
        #[serde(rename = "stats.trades1m")]
        StatsTrades1m,
        #[serde(rename = "stats.trades5m")]
        StatsTrades5m,
        #[serde(rename = "stats.trades1h")]
        StatsTrades1h,
        #[serde(rename = "stats.trades4h")]
        StatsTrades4h,
        #[serde(rename = "stats.trades24h")]
        StatsTrades24h,
        #[serde(rename = "stats.traders1m")]
        StatsTraders1m,
        #[serde(rename = "stats.traders5m")]
        StatsTraders5m,
        #[serde(rename = "stats.traders1h")]
        StatsTraders1h,
        #[serde(rename = "stats.traders4h")]
        StatsTraders4h,
        #[serde(rename = "stats.traders24h")]
        StatsTraders24h,
        #[serde(rename = "stats.volumesInUsd1m")]
        StatsVolumesInUsd1m,
        #[serde(rename = "stats.volumesInUsd5m")]
        StatsVolumesInUsd5m,
        #[serde(rename = "stats.volumesInUsd1h")]
        StatsVolumesInUsd1h,
        #[serde(rename = "stats.volumesInUsd4h")]
        StatsVolumesInUsd4h,
        #[serde(rename = "stats.volumesInUsd24h")]
        StatsVolumesInUsd24h,
        #[serde(rename = "tokenCreatedAt")]
        TokenCreatedAt,
    }
    impl ::std::convert::From<&Self> for GetStocksTokensSortBy {
        fn from(value: &GetStocksTokensSortBy) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for GetStocksTokensSortBy {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::MarketDataPriceInUsd => f.write_str("marketData.priceInUsd"),
                Self::StatsPriceChangeRatioInUsd1m => {
                    f.write_str("stats.priceChangeRatioInUsd1m")
                }
                Self::StatsPriceChangeRatioInUsd5m => {
                    f.write_str("stats.priceChangeRatioInUsd5m")
                }
                Self::StatsPriceChangeRatioInUsd1h => {
                    f.write_str("stats.priceChangeRatioInUsd1h")
                }
                Self::StatsPriceChangeRatioInUsd4h => {
                    f.write_str("stats.priceChangeRatioInUsd4h")
                }
                Self::StatsPriceChangeRatioInUsd24h => {
                    f.write_str("stats.priceChangeRatioInUsd24h")
                }
                Self::MarketDataMarketCapInUsd => {
                    f.write_str("marketData.marketCapInUsd")
                }
                Self::MarketDataMaxPoolTvlInUsd => {
                    f.write_str("marketData.maxPoolTvlInUsd")
                }
                Self::MarketDataTotalTvlInUsd => f.write_str("marketData.totalTvlInUsd"),
                Self::MarketDataTop10TotalHoldings => {
                    f.write_str("marketData.top10TotalHoldings")
                }
                Self::MarketDataTop10HoldingsRatio => {
                    f.write_str("marketData.top10HoldingsRatio")
                }
                Self::MarketDataTop100TotalHoldings => {
                    f.write_str("marketData.top100TotalHoldings")
                }
                Self::MarketDataTop100HoldingsRatio => {
                    f.write_str("marketData.top100HoldingsRatio")
                }
                Self::MarketDataHolders => f.write_str("marketData.holders"),
                Self::MarketDataCreatorHoldings => {
                    f.write_str("marketData.creatorHoldings")
                }
                Self::MarketDataCreatorHoldingsRatio => {
                    f.write_str("marketData.creatorHoldingsRatio")
                }
                Self::StatsBuys1m => f.write_str("stats.buys1m"),
                Self::StatsBuys5m => f.write_str("stats.buys5m"),
                Self::StatsBuys15m => f.write_str("stats.buys15m"),
                Self::StatsBuys30m => f.write_str("stats.buys30m"),
                Self::StatsBuys1h => f.write_str("stats.buys1h"),
                Self::StatsBuys4h => f.write_str("stats.buys4h"),
                Self::StatsBuys24h => f.write_str("stats.buys24h"),
                Self::StatsSells1m => f.write_str("stats.sells1m"),
                Self::StatsSells5m => f.write_str("stats.sells5m"),
                Self::StatsSells15m => f.write_str("stats.sells15m"),
                Self::StatsSells30m => f.write_str("stats.sells30m"),
                Self::StatsSells1h => f.write_str("stats.sells1h"),
                Self::StatsSells4h => f.write_str("stats.sells4h"),
                Self::StatsSells24h => f.write_str("stats.sells24h"),
                Self::StatsTrades1m => f.write_str("stats.trades1m"),
                Self::StatsTrades5m => f.write_str("stats.trades5m"),
                Self::StatsTrades1h => f.write_str("stats.trades1h"),
                Self::StatsTrades4h => f.write_str("stats.trades4h"),
                Self::StatsTrades24h => f.write_str("stats.trades24h"),
                Self::StatsTraders1m => f.write_str("stats.traders1m"),
                Self::StatsTraders5m => f.write_str("stats.traders5m"),
                Self::StatsTraders1h => f.write_str("stats.traders1h"),
                Self::StatsTraders4h => f.write_str("stats.traders4h"),
                Self::StatsTraders24h => f.write_str("stats.traders24h"),
                Self::StatsVolumesInUsd1m => f.write_str("stats.volumesInUsd1m"),
                Self::StatsVolumesInUsd5m => f.write_str("stats.volumesInUsd5m"),
                Self::StatsVolumesInUsd1h => f.write_str("stats.volumesInUsd1h"),
                Self::StatsVolumesInUsd4h => f.write_str("stats.volumesInUsd4h"),
                Self::StatsVolumesInUsd24h => f.write_str("stats.volumesInUsd24h"),
                Self::TokenCreatedAt => f.write_str("tokenCreatedAt"),
            }
        }
    }
    impl ::std::str::FromStr for GetStocksTokensSortBy {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "marketData.priceInUsd" => Ok(Self::MarketDataPriceInUsd),
                "stats.priceChangeRatioInUsd1m" => Ok(Self::StatsPriceChangeRatioInUsd1m),
                "stats.priceChangeRatioInUsd5m" => Ok(Self::StatsPriceChangeRatioInUsd5m),
                "stats.priceChangeRatioInUsd1h" => Ok(Self::StatsPriceChangeRatioInUsd1h),
                "stats.priceChangeRatioInUsd4h" => Ok(Self::StatsPriceChangeRatioInUsd4h),
                "stats.priceChangeRatioInUsd24h" => {
                    Ok(Self::StatsPriceChangeRatioInUsd24h)
                }
                "marketData.marketCapInUsd" => Ok(Self::MarketDataMarketCapInUsd),
                "marketData.maxPoolTvlInUsd" => Ok(Self::MarketDataMaxPoolTvlInUsd),
                "marketData.totalTvlInUsd" => Ok(Self::MarketDataTotalTvlInUsd),
                "marketData.top10TotalHoldings" => Ok(Self::MarketDataTop10TotalHoldings),
                "marketData.top10HoldingsRatio" => Ok(Self::MarketDataTop10HoldingsRatio),
                "marketData.top100TotalHoldings" => {
                    Ok(Self::MarketDataTop100TotalHoldings)
                }
                "marketData.top100HoldingsRatio" => {
                    Ok(Self::MarketDataTop100HoldingsRatio)
                }
                "marketData.holders" => Ok(Self::MarketDataHolders),
                "marketData.creatorHoldings" => Ok(Self::MarketDataCreatorHoldings),
                "marketData.creatorHoldingsRatio" => {
                    Ok(Self::MarketDataCreatorHoldingsRatio)
                }
                "stats.buys1m" => Ok(Self::StatsBuys1m),
                "stats.buys5m" => Ok(Self::StatsBuys5m),
                "stats.buys15m" => Ok(Self::StatsBuys15m),
                "stats.buys30m" => Ok(Self::StatsBuys30m),
                "stats.buys1h" => Ok(Self::StatsBuys1h),
                "stats.buys4h" => Ok(Self::StatsBuys4h),
                "stats.buys24h" => Ok(Self::StatsBuys24h),
                "stats.sells1m" => Ok(Self::StatsSells1m),
                "stats.sells5m" => Ok(Self::StatsSells5m),
                "stats.sells15m" => Ok(Self::StatsSells15m),
                "stats.sells30m" => Ok(Self::StatsSells30m),
                "stats.sells1h" => Ok(Self::StatsSells1h),
                "stats.sells4h" => Ok(Self::StatsSells4h),
                "stats.sells24h" => Ok(Self::StatsSells24h),
                "stats.trades1m" => Ok(Self::StatsTrades1m),
                "stats.trades5m" => Ok(Self::StatsTrades5m),
                "stats.trades1h" => Ok(Self::StatsTrades1h),
                "stats.trades4h" => Ok(Self::StatsTrades4h),
                "stats.trades24h" => Ok(Self::StatsTrades24h),
                "stats.traders1m" => Ok(Self::StatsTraders1m),
                "stats.traders5m" => Ok(Self::StatsTraders5m),
                "stats.traders1h" => Ok(Self::StatsTraders1h),
                "stats.traders4h" => Ok(Self::StatsTraders4h),
                "stats.traders24h" => Ok(Self::StatsTraders24h),
                "stats.volumesInUsd1m" => Ok(Self::StatsVolumesInUsd1m),
                "stats.volumesInUsd5m" => Ok(Self::StatsVolumesInUsd5m),
                "stats.volumesInUsd1h" => Ok(Self::StatsVolumesInUsd1h),
                "stats.volumesInUsd4h" => Ok(Self::StatsVolumesInUsd4h),
                "stats.volumesInUsd24h" => Ok(Self::StatsVolumesInUsd24h),
                "tokenCreatedAt" => Ok(Self::TokenCreatedAt),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for GetStocksTokensSortBy {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String> for GetStocksTokensSortBy {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for GetStocksTokensSortBy {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    ///`GetStocksTokensSortDirection`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "default": "DESC",
    ///  "type": "string",
    ///  "enum": [
    ///    "ASC",
    ///    "DESC"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum GetStocksTokensSortDirection {
        #[serde(rename = "ASC")]
        Asc,
        #[serde(rename = "DESC")]
        Desc,
    }
    impl ::std::convert::From<&Self> for GetStocksTokensSortDirection {
        fn from(value: &GetStocksTokensSortDirection) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for GetStocksTokensSortDirection {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::Asc => f.write_str("ASC"),
                Self::Desc => f.write_str("DESC"),
            }
        }
    }
    impl ::std::str::FromStr for GetStocksTokensSortDirection {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "ASC" => Ok(Self::Asc),
                "DESC" => Ok(Self::Desc),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for GetStocksTokensSortDirection {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String>
    for GetStocksTokensSortDirection {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String>
    for GetStocksTokensSortDirection {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::default::Default for GetStocksTokensSortDirection {
        fn default() -> Self {
            GetStocksTokensSortDirection::Desc
        }
    }
    ///`GetStocksTokensTag`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "string",
    ///  "enum": [
    ///    "pump_fun",
    ///    "raydium_launchpad",
    ///    "meteora_dynamic_bounding_curve",
    ///    "bonk_fun",
    ///    "moonit_fun"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum GetStocksTokensTag {
        #[serde(rename = "pump_fun")]
        PumpFun,
        #[serde(rename = "raydium_launchpad")]
        RaydiumLaunchpad,
        #[serde(rename = "meteora_dynamic_bounding_curve")]
        MeteoraDynamicBoundingCurve,
        #[serde(rename = "bonk_fun")]
        BonkFun,
        #[serde(rename = "moonit_fun")]
        MoonitFun,
    }
    impl ::std::convert::From<&Self> for GetStocksTokensTag {
        fn from(value: &GetStocksTokensTag) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for GetStocksTokensTag {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::PumpFun => f.write_str("pump_fun"),
                Self::RaydiumLaunchpad => f.write_str("raydium_launchpad"),
                Self::MeteoraDynamicBoundingCurve => {
                    f.write_str("meteora_dynamic_bounding_curve")
                }
                Self::BonkFun => f.write_str("bonk_fun"),
                Self::MoonitFun => f.write_str("moonit_fun"),
            }
        }
    }
    impl ::std::str::FromStr for GetStocksTokensTag {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "pump_fun" => Ok(Self::PumpFun),
                "raydium_launchpad" => Ok(Self::RaydiumLaunchpad),
                "meteora_dynamic_bounding_curve" => Ok(Self::MeteoraDynamicBoundingCurve),
                "bonk_fun" => Ok(Self::BonkFun),
                "moonit_fun" => Ok(Self::MoonitFun),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for GetStocksTokensTag {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String> for GetStocksTokensTag {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for GetStocksTokensTag {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    ///`GetTokenLiquiditySnapshotsDirection`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "default": "next",
    ///  "type": "string",
    ///  "enum": [
    ///    "next",
    ///    "prev"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum GetTokenLiquiditySnapshotsDirection {
        #[serde(rename = "next")]
        Next,
        #[serde(rename = "prev")]
        Prev,
    }
    impl ::std::convert::From<&Self> for GetTokenLiquiditySnapshotsDirection {
        fn from(value: &GetTokenLiquiditySnapshotsDirection) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for GetTokenLiquiditySnapshotsDirection {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::Next => f.write_str("next"),
                Self::Prev => f.write_str("prev"),
            }
        }
    }
    impl ::std::str::FromStr for GetTokenLiquiditySnapshotsDirection {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "next" => Ok(Self::Next),
                "prev" => Ok(Self::Prev),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for GetTokenLiquiditySnapshotsDirection {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String>
    for GetTokenLiquiditySnapshotsDirection {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String>
    for GetTokenLiquiditySnapshotsDirection {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::default::Default for GetTokenLiquiditySnapshotsDirection {
        fn default() -> Self {
            GetTokenLiquiditySnapshotsDirection::Next
        }
    }
    ///`GetTokenTransferTotalDirection`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "default": "next",
    ///  "type": "string",
    ///  "enum": [
    ///    "next",
    ///    "prev"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum GetTokenTransferTotalDirection {
        #[serde(rename = "next")]
        Next,
        #[serde(rename = "prev")]
        Prev,
    }
    impl ::std::convert::From<&Self> for GetTokenTransferTotalDirection {
        fn from(value: &GetTokenTransferTotalDirection) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for GetTokenTransferTotalDirection {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::Next => f.write_str("next"),
                Self::Prev => f.write_str("prev"),
            }
        }
    }
    impl ::std::str::FromStr for GetTokenTransferTotalDirection {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "next" => Ok(Self::Next),
                "prev" => Ok(Self::Prev),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for GetTokenTransferTotalDirection {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String>
    for GetTokenTransferTotalDirection {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String>
    for GetTokenTransferTotalDirection {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::default::Default for GetTokenTransferTotalDirection {
        fn default() -> Self {
            GetTokenTransferTotalDirection::Next
        }
    }
    ///`GetTokenTransfersDirection`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "default": "next",
    ///  "type": "string",
    ///  "enum": [
    ///    "next",
    ///    "prev"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum GetTokenTransfersDirection {
        #[serde(rename = "next")]
        Next,
        #[serde(rename = "prev")]
        Prev,
    }
    impl ::std::convert::From<&Self> for GetTokenTransfersDirection {
        fn from(value: &GetTokenTransfersDirection) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for GetTokenTransfersDirection {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::Next => f.write_str("next"),
                Self::Prev => f.write_str("prev"),
            }
        }
    }
    impl ::std::str::FromStr for GetTokenTransfersDirection {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "next" => Ok(Self::Next),
                "prev" => Ok(Self::Prev),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for GetTokenTransfersDirection {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String> for GetTokenTransfersDirection {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for GetTokenTransfersDirection {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::default::Default for GetTokenTransfersDirection {
        fn default() -> Self {
            GetTokenTransfersDirection::Next
        }
    }
    ///`GetTokensBalanceDirection`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "default": "next",
    ///  "type": "string",
    ///  "enum": [
    ///    "next",
    ///    "prev"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum GetTokensBalanceDirection {
        #[serde(rename = "next")]
        Next,
        #[serde(rename = "prev")]
        Prev,
    }
    impl ::std::convert::From<&Self> for GetTokensBalanceDirection {
        fn from(value: &GetTokensBalanceDirection) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for GetTokensBalanceDirection {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::Next => f.write_str("next"),
                Self::Prev => f.write_str("prev"),
            }
        }
    }
    impl ::std::str::FromStr for GetTokensBalanceDirection {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "next" => Ok(Self::Next),
                "prev" => Ok(Self::Prev),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for GetTokensBalanceDirection {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String> for GetTokensBalanceDirection {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for GetTokensBalanceDirection {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::default::Default for GetTokensBalanceDirection {
        fn default() -> Self {
            GetTokensBalanceDirection::Next
        }
    }
    ///`GetTokensSortBy`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "examples": [
    ///    "marketData.marketCapInUsd"
    ///  ],
    ///  "type": "string",
    ///  "enum": [
    ///    "marketData.priceInUsd",
    ///    "stats.priceChangeRatioInUsd1m",
    ///    "stats.priceChangeRatioInUsd5m",
    ///    "stats.priceChangeRatioInUsd1h",
    ///    "stats.priceChangeRatioInUsd4h",
    ///    "stats.priceChangeRatioInUsd24h",
    ///    "marketData.marketCapInUsd",
    ///    "marketData.maxPoolTvlInUsd",
    ///    "marketData.totalTvlInUsd",
    ///    "marketData.top10TotalHoldings",
    ///    "marketData.top10HoldingsRatio",
    ///    "marketData.top100TotalHoldings",
    ///    "marketData.top100HoldingsRatio",
    ///    "marketData.holders",
    ///    "marketData.creatorHoldings",
    ///    "marketData.creatorHoldingsRatio",
    ///    "stats.buys1m",
    ///    "stats.buys5m",
    ///    "stats.buys15m",
    ///    "stats.buys30m",
    ///    "stats.buys1h",
    ///    "stats.buys4h",
    ///    "stats.buys24h",
    ///    "stats.sells1m",
    ///    "stats.sells5m",
    ///    "stats.sells15m",
    ///    "stats.sells30m",
    ///    "stats.sells1h",
    ///    "stats.sells4h",
    ///    "stats.sells24h",
    ///    "stats.trades1m",
    ///    "stats.trades5m",
    ///    "stats.trades1h",
    ///    "stats.trades4h",
    ///    "stats.trades24h",
    ///    "stats.traders1m",
    ///    "stats.traders5m",
    ///    "stats.traders1h",
    ///    "stats.traders4h",
    ///    "stats.traders24h",
    ///    "stats.volumesInUsd1m",
    ///    "stats.volumesInUsd5m",
    ///    "stats.volumesInUsd1h",
    ///    "stats.volumesInUsd4h",
    ///    "stats.volumesInUsd24h",
    ///    "tokenCreatedAt"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum GetTokensSortBy {
        #[serde(rename = "marketData.priceInUsd")]
        MarketDataPriceInUsd,
        #[serde(rename = "stats.priceChangeRatioInUsd1m")]
        StatsPriceChangeRatioInUsd1m,
        #[serde(rename = "stats.priceChangeRatioInUsd5m")]
        StatsPriceChangeRatioInUsd5m,
        #[serde(rename = "stats.priceChangeRatioInUsd1h")]
        StatsPriceChangeRatioInUsd1h,
        #[serde(rename = "stats.priceChangeRatioInUsd4h")]
        StatsPriceChangeRatioInUsd4h,
        #[serde(rename = "stats.priceChangeRatioInUsd24h")]
        StatsPriceChangeRatioInUsd24h,
        #[serde(rename = "marketData.marketCapInUsd")]
        MarketDataMarketCapInUsd,
        #[serde(rename = "marketData.maxPoolTvlInUsd")]
        MarketDataMaxPoolTvlInUsd,
        #[serde(rename = "marketData.totalTvlInUsd")]
        MarketDataTotalTvlInUsd,
        #[serde(rename = "marketData.top10TotalHoldings")]
        MarketDataTop10TotalHoldings,
        #[serde(rename = "marketData.top10HoldingsRatio")]
        MarketDataTop10HoldingsRatio,
        #[serde(rename = "marketData.top100TotalHoldings")]
        MarketDataTop100TotalHoldings,
        #[serde(rename = "marketData.top100HoldingsRatio")]
        MarketDataTop100HoldingsRatio,
        #[serde(rename = "marketData.holders")]
        MarketDataHolders,
        #[serde(rename = "marketData.creatorHoldings")]
        MarketDataCreatorHoldings,
        #[serde(rename = "marketData.creatorHoldingsRatio")]
        MarketDataCreatorHoldingsRatio,
        #[serde(rename = "stats.buys1m")]
        StatsBuys1m,
        #[serde(rename = "stats.buys5m")]
        StatsBuys5m,
        #[serde(rename = "stats.buys15m")]
        StatsBuys15m,
        #[serde(rename = "stats.buys30m")]
        StatsBuys30m,
        #[serde(rename = "stats.buys1h")]
        StatsBuys1h,
        #[serde(rename = "stats.buys4h")]
        StatsBuys4h,
        #[serde(rename = "stats.buys24h")]
        StatsBuys24h,
        #[serde(rename = "stats.sells1m")]
        StatsSells1m,
        #[serde(rename = "stats.sells5m")]
        StatsSells5m,
        #[serde(rename = "stats.sells15m")]
        StatsSells15m,
        #[serde(rename = "stats.sells30m")]
        StatsSells30m,
        #[serde(rename = "stats.sells1h")]
        StatsSells1h,
        #[serde(rename = "stats.sells4h")]
        StatsSells4h,
        #[serde(rename = "stats.sells24h")]
        StatsSells24h,
        #[serde(rename = "stats.trades1m")]
        StatsTrades1m,
        #[serde(rename = "stats.trades5m")]
        StatsTrades5m,
        #[serde(rename = "stats.trades1h")]
        StatsTrades1h,
        #[serde(rename = "stats.trades4h")]
        StatsTrades4h,
        #[serde(rename = "stats.trades24h")]
        StatsTrades24h,
        #[serde(rename = "stats.traders1m")]
        StatsTraders1m,
        #[serde(rename = "stats.traders5m")]
        StatsTraders5m,
        #[serde(rename = "stats.traders1h")]
        StatsTraders1h,
        #[serde(rename = "stats.traders4h")]
        StatsTraders4h,
        #[serde(rename = "stats.traders24h")]
        StatsTraders24h,
        #[serde(rename = "stats.volumesInUsd1m")]
        StatsVolumesInUsd1m,
        #[serde(rename = "stats.volumesInUsd5m")]
        StatsVolumesInUsd5m,
        #[serde(rename = "stats.volumesInUsd1h")]
        StatsVolumesInUsd1h,
        #[serde(rename = "stats.volumesInUsd4h")]
        StatsVolumesInUsd4h,
        #[serde(rename = "stats.volumesInUsd24h")]
        StatsVolumesInUsd24h,
        #[serde(rename = "tokenCreatedAt")]
        TokenCreatedAt,
    }
    impl ::std::convert::From<&Self> for GetTokensSortBy {
        fn from(value: &GetTokensSortBy) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for GetTokensSortBy {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::MarketDataPriceInUsd => f.write_str("marketData.priceInUsd"),
                Self::StatsPriceChangeRatioInUsd1m => {
                    f.write_str("stats.priceChangeRatioInUsd1m")
                }
                Self::StatsPriceChangeRatioInUsd5m => {
                    f.write_str("stats.priceChangeRatioInUsd5m")
                }
                Self::StatsPriceChangeRatioInUsd1h => {
                    f.write_str("stats.priceChangeRatioInUsd1h")
                }
                Self::StatsPriceChangeRatioInUsd4h => {
                    f.write_str("stats.priceChangeRatioInUsd4h")
                }
                Self::StatsPriceChangeRatioInUsd24h => {
                    f.write_str("stats.priceChangeRatioInUsd24h")
                }
                Self::MarketDataMarketCapInUsd => {
                    f.write_str("marketData.marketCapInUsd")
                }
                Self::MarketDataMaxPoolTvlInUsd => {
                    f.write_str("marketData.maxPoolTvlInUsd")
                }
                Self::MarketDataTotalTvlInUsd => f.write_str("marketData.totalTvlInUsd"),
                Self::MarketDataTop10TotalHoldings => {
                    f.write_str("marketData.top10TotalHoldings")
                }
                Self::MarketDataTop10HoldingsRatio => {
                    f.write_str("marketData.top10HoldingsRatio")
                }
                Self::MarketDataTop100TotalHoldings => {
                    f.write_str("marketData.top100TotalHoldings")
                }
                Self::MarketDataTop100HoldingsRatio => {
                    f.write_str("marketData.top100HoldingsRatio")
                }
                Self::MarketDataHolders => f.write_str("marketData.holders"),
                Self::MarketDataCreatorHoldings => {
                    f.write_str("marketData.creatorHoldings")
                }
                Self::MarketDataCreatorHoldingsRatio => {
                    f.write_str("marketData.creatorHoldingsRatio")
                }
                Self::StatsBuys1m => f.write_str("stats.buys1m"),
                Self::StatsBuys5m => f.write_str("stats.buys5m"),
                Self::StatsBuys15m => f.write_str("stats.buys15m"),
                Self::StatsBuys30m => f.write_str("stats.buys30m"),
                Self::StatsBuys1h => f.write_str("stats.buys1h"),
                Self::StatsBuys4h => f.write_str("stats.buys4h"),
                Self::StatsBuys24h => f.write_str("stats.buys24h"),
                Self::StatsSells1m => f.write_str("stats.sells1m"),
                Self::StatsSells5m => f.write_str("stats.sells5m"),
                Self::StatsSells15m => f.write_str("stats.sells15m"),
                Self::StatsSells30m => f.write_str("stats.sells30m"),
                Self::StatsSells1h => f.write_str("stats.sells1h"),
                Self::StatsSells4h => f.write_str("stats.sells4h"),
                Self::StatsSells24h => f.write_str("stats.sells24h"),
                Self::StatsTrades1m => f.write_str("stats.trades1m"),
                Self::StatsTrades5m => f.write_str("stats.trades5m"),
                Self::StatsTrades1h => f.write_str("stats.trades1h"),
                Self::StatsTrades4h => f.write_str("stats.trades4h"),
                Self::StatsTrades24h => f.write_str("stats.trades24h"),
                Self::StatsTraders1m => f.write_str("stats.traders1m"),
                Self::StatsTraders5m => f.write_str("stats.traders5m"),
                Self::StatsTraders1h => f.write_str("stats.traders1h"),
                Self::StatsTraders4h => f.write_str("stats.traders4h"),
                Self::StatsTraders24h => f.write_str("stats.traders24h"),
                Self::StatsVolumesInUsd1m => f.write_str("stats.volumesInUsd1m"),
                Self::StatsVolumesInUsd5m => f.write_str("stats.volumesInUsd5m"),
                Self::StatsVolumesInUsd1h => f.write_str("stats.volumesInUsd1h"),
                Self::StatsVolumesInUsd4h => f.write_str("stats.volumesInUsd4h"),
                Self::StatsVolumesInUsd24h => f.write_str("stats.volumesInUsd24h"),
                Self::TokenCreatedAt => f.write_str("tokenCreatedAt"),
            }
        }
    }
    impl ::std::str::FromStr for GetTokensSortBy {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "marketData.priceInUsd" => Ok(Self::MarketDataPriceInUsd),
                "stats.priceChangeRatioInUsd1m" => Ok(Self::StatsPriceChangeRatioInUsd1m),
                "stats.priceChangeRatioInUsd5m" => Ok(Self::StatsPriceChangeRatioInUsd5m),
                "stats.priceChangeRatioInUsd1h" => Ok(Self::StatsPriceChangeRatioInUsd1h),
                "stats.priceChangeRatioInUsd4h" => Ok(Self::StatsPriceChangeRatioInUsd4h),
                "stats.priceChangeRatioInUsd24h" => {
                    Ok(Self::StatsPriceChangeRatioInUsd24h)
                }
                "marketData.marketCapInUsd" => Ok(Self::MarketDataMarketCapInUsd),
                "marketData.maxPoolTvlInUsd" => Ok(Self::MarketDataMaxPoolTvlInUsd),
                "marketData.totalTvlInUsd" => Ok(Self::MarketDataTotalTvlInUsd),
                "marketData.top10TotalHoldings" => Ok(Self::MarketDataTop10TotalHoldings),
                "marketData.top10HoldingsRatio" => Ok(Self::MarketDataTop10HoldingsRatio),
                "marketData.top100TotalHoldings" => {
                    Ok(Self::MarketDataTop100TotalHoldings)
                }
                "marketData.top100HoldingsRatio" => {
                    Ok(Self::MarketDataTop100HoldingsRatio)
                }
                "marketData.holders" => Ok(Self::MarketDataHolders),
                "marketData.creatorHoldings" => Ok(Self::MarketDataCreatorHoldings),
                "marketData.creatorHoldingsRatio" => {
                    Ok(Self::MarketDataCreatorHoldingsRatio)
                }
                "stats.buys1m" => Ok(Self::StatsBuys1m),
                "stats.buys5m" => Ok(Self::StatsBuys5m),
                "stats.buys15m" => Ok(Self::StatsBuys15m),
                "stats.buys30m" => Ok(Self::StatsBuys30m),
                "stats.buys1h" => Ok(Self::StatsBuys1h),
                "stats.buys4h" => Ok(Self::StatsBuys4h),
                "stats.buys24h" => Ok(Self::StatsBuys24h),
                "stats.sells1m" => Ok(Self::StatsSells1m),
                "stats.sells5m" => Ok(Self::StatsSells5m),
                "stats.sells15m" => Ok(Self::StatsSells15m),
                "stats.sells30m" => Ok(Self::StatsSells30m),
                "stats.sells1h" => Ok(Self::StatsSells1h),
                "stats.sells4h" => Ok(Self::StatsSells4h),
                "stats.sells24h" => Ok(Self::StatsSells24h),
                "stats.trades1m" => Ok(Self::StatsTrades1m),
                "stats.trades5m" => Ok(Self::StatsTrades5m),
                "stats.trades1h" => Ok(Self::StatsTrades1h),
                "stats.trades4h" => Ok(Self::StatsTrades4h),
                "stats.trades24h" => Ok(Self::StatsTrades24h),
                "stats.traders1m" => Ok(Self::StatsTraders1m),
                "stats.traders5m" => Ok(Self::StatsTraders5m),
                "stats.traders1h" => Ok(Self::StatsTraders1h),
                "stats.traders4h" => Ok(Self::StatsTraders4h),
                "stats.traders24h" => Ok(Self::StatsTraders24h),
                "stats.volumesInUsd1m" => Ok(Self::StatsVolumesInUsd1m),
                "stats.volumesInUsd5m" => Ok(Self::StatsVolumesInUsd5m),
                "stats.volumesInUsd1h" => Ok(Self::StatsVolumesInUsd1h),
                "stats.volumesInUsd4h" => Ok(Self::StatsVolumesInUsd4h),
                "stats.volumesInUsd24h" => Ok(Self::StatsVolumesInUsd24h),
                "tokenCreatedAt" => Ok(Self::TokenCreatedAt),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for GetTokensSortBy {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String> for GetTokensSortBy {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for GetTokensSortBy {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    ///`GetTokensSortDirection`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "default": "DESC",
    ///  "type": "string",
    ///  "enum": [
    ///    "ASC",
    ///    "DESC"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum GetTokensSortDirection {
        #[serde(rename = "ASC")]
        Asc,
        #[serde(rename = "DESC")]
        Desc,
    }
    impl ::std::convert::From<&Self> for GetTokensSortDirection {
        fn from(value: &GetTokensSortDirection) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for GetTokensSortDirection {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::Asc => f.write_str("ASC"),
                Self::Desc => f.write_str("DESC"),
            }
        }
    }
    impl ::std::str::FromStr for GetTokensSortDirection {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "ASC" => Ok(Self::Asc),
                "DESC" => Ok(Self::Desc),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for GetTokensSortDirection {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String> for GetTokensSortDirection {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for GetTokensSortDirection {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::default::Default for GetTokensSortDirection {
        fn default() -> Self {
            GetTokensSortDirection::Desc
        }
    }
    ///`GetTopTradersDirection`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "default": "next",
    ///  "type": "string",
    ///  "enum": [
    ///    "next",
    ///    "prev"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum GetTopTradersDirection {
        #[serde(rename = "next")]
        Next,
        #[serde(rename = "prev")]
        Prev,
    }
    impl ::std::convert::From<&Self> for GetTopTradersDirection {
        fn from(value: &GetTopTradersDirection) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for GetTopTradersDirection {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::Next => f.write_str("next"),
                Self::Prev => f.write_str("prev"),
            }
        }
    }
    impl ::std::str::FromStr for GetTopTradersDirection {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "next" => Ok(Self::Next),
                "prev" => Ok(Self::Prev),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for GetTopTradersDirection {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String> for GetTopTradersDirection {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for GetTopTradersDirection {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::default::Default for GetTopTradersDirection {
        fn default() -> Self {
            GetTopTradersDirection::Next
        }
    }
    ///`GetTopTradersSortBy`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "default": "tradeAmount",
    ///  "examples": [
    ///    "tradeAmount"
    ///  ],
    ///  "type": "string",
    ///  "enum": [
    ///    "tradeAmount",
    ///    "tradeCount"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum GetTopTradersSortBy {
        #[serde(rename = "tradeAmount")]
        TradeAmount,
        #[serde(rename = "tradeCount")]
        TradeCount,
    }
    impl ::std::convert::From<&Self> for GetTopTradersSortBy {
        fn from(value: &GetTopTradersSortBy) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for GetTopTradersSortBy {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::TradeAmount => f.write_str("tradeAmount"),
                Self::TradeCount => f.write_str("tradeCount"),
            }
        }
    }
    impl ::std::str::FromStr for GetTopTradersSortBy {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "tradeAmount" => Ok(Self::TradeAmount),
                "tradeCount" => Ok(Self::TradeCount),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for GetTopTradersSortBy {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String> for GetTopTradersSortBy {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for GetTopTradersSortBy {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::default::Default for GetTopTradersSortBy {
        fn default() -> Self {
            GetTopTradersSortBy::TradeAmount
        }
    }
    ///`GetTopTradersSortType`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "default": "desc",
    ///  "examples": [
    ///    "desc"
    ///  ],
    ///  "type": "string",
    ///  "enum": [
    ///    "desc",
    ///    "asc"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum GetTopTradersSortType {
        #[serde(rename = "desc")]
        Desc,
        #[serde(rename = "asc")]
        Asc,
    }
    impl ::std::convert::From<&Self> for GetTopTradersSortType {
        fn from(value: &GetTopTradersSortType) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for GetTopTradersSortType {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::Desc => f.write_str("desc"),
                Self::Asc => f.write_str("asc"),
            }
        }
    }
    impl ::std::str::FromStr for GetTopTradersSortType {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "desc" => Ok(Self::Desc),
                "asc" => Ok(Self::Asc),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for GetTopTradersSortType {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String> for GetTopTradersSortType {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for GetTopTradersSortType {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::default::Default for GetTopTradersSortType {
        fn default() -> Self {
            GetTopTradersSortType::Desc
        }
    }
    ///`GetTopTradersTimeFrame`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "default": "24h",
    ///  "examples": [
    ///    "24h"
    ///  ],
    ///  "type": "string",
    ///  "enum": [
    ///    "30m",
    ///    "1h",
    ///    "2h",
    ///    "4h",
    ///    "6h",
    ///    "8h",
    ///    "12h",
    ///    "24h"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum GetTopTradersTimeFrame {
        #[serde(rename = "30m")]
        X30m,
        #[serde(rename = "1h")]
        X1h,
        #[serde(rename = "2h")]
        X2h,
        #[serde(rename = "4h")]
        X4h,
        #[serde(rename = "6h")]
        X6h,
        #[serde(rename = "8h")]
        X8h,
        #[serde(rename = "12h")]
        X12h,
        #[serde(rename = "24h")]
        X24h,
    }
    impl ::std::convert::From<&Self> for GetTopTradersTimeFrame {
        fn from(value: &GetTopTradersTimeFrame) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for GetTopTradersTimeFrame {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::X30m => f.write_str("30m"),
                Self::X1h => f.write_str("1h"),
                Self::X2h => f.write_str("2h"),
                Self::X4h => f.write_str("4h"),
                Self::X6h => f.write_str("6h"),
                Self::X8h => f.write_str("8h"),
                Self::X12h => f.write_str("12h"),
                Self::X24h => f.write_str("24h"),
            }
        }
    }
    impl ::std::str::FromStr for GetTopTradersTimeFrame {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "30m" => Ok(Self::X30m),
                "1h" => Ok(Self::X1h),
                "2h" => Ok(Self::X2h),
                "4h" => Ok(Self::X4h),
                "6h" => Ok(Self::X6h),
                "8h" => Ok(Self::X8h),
                "12h" => Ok(Self::X12h),
                "24h" => Ok(Self::X24h),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for GetTopTradersTimeFrame {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String> for GetTopTradersTimeFrame {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for GetTopTradersTimeFrame {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::default::Default for GetTopTradersTimeFrame {
        fn default() -> Self {
            GetTopTradersTimeFrame::X24h
        }
    }
    ///`GetTraderGainersLosersDirection`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "default": "next",
    ///  "type": "string",
    ///  "enum": [
    ///    "next",
    ///    "prev"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum GetTraderGainersLosersDirection {
        #[serde(rename = "next")]
        Next,
        #[serde(rename = "prev")]
        Prev,
    }
    impl ::std::convert::From<&Self> for GetTraderGainersLosersDirection {
        fn from(value: &GetTraderGainersLosersDirection) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for GetTraderGainersLosersDirection {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::Next => f.write_str("next"),
                Self::Prev => f.write_str("prev"),
            }
        }
    }
    impl ::std::str::FromStr for GetTraderGainersLosersDirection {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "next" => Ok(Self::Next),
                "prev" => Ok(Self::Prev),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for GetTraderGainersLosersDirection {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String>
    for GetTraderGainersLosersDirection {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String>
    for GetTraderGainersLosersDirection {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::default::Default for GetTraderGainersLosersDirection {
        fn default() -> Self {
            GetTraderGainersLosersDirection::Next
        }
    }
    ///`GetTraderGainersLosersSortType`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "default": "desc",
    ///  "examples": [
    ///    "desc"
    ///  ],
    ///  "type": "string",
    ///  "enum": [
    ///    "desc",
    ///    "asc"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum GetTraderGainersLosersSortType {
        #[serde(rename = "desc")]
        Desc,
        #[serde(rename = "asc")]
        Asc,
    }
    impl ::std::convert::From<&Self> for GetTraderGainersLosersSortType {
        fn from(value: &GetTraderGainersLosersSortType) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for GetTraderGainersLosersSortType {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::Desc => f.write_str("desc"),
                Self::Asc => f.write_str("asc"),
            }
        }
    }
    impl ::std::str::FromStr for GetTraderGainersLosersSortType {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "desc" => Ok(Self::Desc),
                "asc" => Ok(Self::Asc),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for GetTraderGainersLosersSortType {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String>
    for GetTraderGainersLosersSortType {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String>
    for GetTraderGainersLosersSortType {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::default::Default for GetTraderGainersLosersSortType {
        fn default() -> Self {
            GetTraderGainersLosersSortType::Desc
        }
    }
    ///`GetTradesDirection`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "default": "next",
    ///  "type": "string",
    ///  "enum": [
    ///    "next",
    ///    "prev"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum GetTradesDirection {
        #[serde(rename = "next")]
        Next,
        #[serde(rename = "prev")]
        Prev,
    }
    impl ::std::convert::From<&Self> for GetTradesDirection {
        fn from(value: &GetTradesDirection) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for GetTradesDirection {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::Next => f.write_str("next"),
                Self::Prev => f.write_str("prev"),
            }
        }
    }
    impl ::std::str::FromStr for GetTradesDirection {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "next" => Ok(Self::Next),
                "prev" => Ok(Self::Prev),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for GetTradesDirection {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String> for GetTradesDirection {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for GetTradesDirection {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::default::Default for GetTradesDirection {
        fn default() -> Self {
            GetTradesDirection::Next
        }
    }
    ///`GetTradesType`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "examples": [
    ///    "BUY"
    ///  ],
    ///  "type": "string",
    ///  "enum": [
    ///    "BUY",
    ///    "SELL"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum GetTradesType {
        #[serde(rename = "BUY")]
        Buy,
        #[serde(rename = "SELL")]
        Sell,
    }
    impl ::std::convert::From<&Self> for GetTradesType {
        fn from(value: &GetTradesType) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for GetTradesType {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::Buy => f.write_str("BUY"),
                Self::Sell => f.write_str("SELL"),
            }
        }
    }
    impl ::std::str::FromStr for GetTradesType {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "BUY" => Ok(Self::Buy),
                "SELL" => Ok(Self::Sell),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for GetTradesType {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String> for GetTradesType {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for GetTradesType {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    ///`GetWalletTransferTotalDirection`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "default": "next",
    ///  "type": "string",
    ///  "enum": [
    ///    "next",
    ///    "prev"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum GetWalletTransferTotalDirection {
        #[serde(rename = "next")]
        Next,
        #[serde(rename = "prev")]
        Prev,
    }
    impl ::std::convert::From<&Self> for GetWalletTransferTotalDirection {
        fn from(value: &GetWalletTransferTotalDirection) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for GetWalletTransferTotalDirection {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::Next => f.write_str("next"),
                Self::Prev => f.write_str("prev"),
            }
        }
    }
    impl ::std::str::FromStr for GetWalletTransferTotalDirection {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "next" => Ok(Self::Next),
                "prev" => Ok(Self::Prev),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for GetWalletTransferTotalDirection {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String>
    for GetWalletTransferTotalDirection {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String>
    for GetWalletTransferTotalDirection {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::default::Default for GetWalletTransferTotalDirection {
        fn default() -> Self {
            GetWalletTransferTotalDirection::Next
        }
    }
    ///`GetWalletTransfersDirection`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "default": "next",
    ///  "type": "string",
    ///  "enum": [
    ///    "next",
    ///    "prev"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum GetWalletTransfersDirection {
        #[serde(rename = "next")]
        Next,
        #[serde(rename = "prev")]
        Prev,
    }
    impl ::std::convert::From<&Self> for GetWalletTransfersDirection {
        fn from(value: &GetWalletTransfersDirection) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for GetWalletTransfersDirection {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::Next => f.write_str("next"),
                Self::Prev => f.write_str("prev"),
            }
        }
    }
    impl ::std::str::FromStr for GetWalletTransfersDirection {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "next" => Ok(Self::Next),
                "prev" => Ok(Self::Prev),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for GetWalletTransfersDirection {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String>
    for GetWalletTransfersDirection {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for GetWalletTransfersDirection {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::default::Default for GetWalletTransfersDirection {
        fn default() -> Self {
            GetWalletTransfersDirection::Next
        }
    }
    ///`JobDto`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "result",
    ///    "state"
    ///  ],
    ///  "properties": {
    ///    "result": {
    ///      "description": "DTO.JOB.RESULT",
    ///      "examples": [
    ///        {
    ///          "data": {
    ///            "message": "Job completed successfully"
    ///          },
    ///          "success": true
    ///        }
    ///      ],
    ///      "type": "object"
    ///    },
    ///    "state": {
    ///      "description": "DTO.JOB.STATE",
    ///      "examples": [
    ///        "completed"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct JobDto {
        ///DTO.JOB.RESULT
        pub result: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
        ///DTO.JOB.STATE
        pub state: ::std::string::String,
    }
    impl ::std::convert::From<&JobDto> for JobDto {
        fn from(value: &JobDto) -> Self {
            value.clone()
        }
    }
    impl JobDto {
        pub fn builder() -> builder::JobDto {
            Default::default()
        }
    }
    ///`JobStreamingDto`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "data",
    ///    "id"
    ///  ],
    ///  "properties": {
    ///    "data": {
    ///      "description": "DTO.JOB.STREAMING.DATA",
    ///      "examples": [
    ///        {
    ///          "id": "5rKfmXQyMhz7F2zRE6SpWWx3YkSxtA4gFqZD8CwGRYMx5YLTB8NhbiM9xEHG9jruiWdUyUz7Fpz8jmB8SKcjsLqe",
    ///          "result": {
    ///            "data": {
    ///              "message": "Job completed successfully"
    ///            },
    ///            "success": true
    ///          },
    ///          "status": "completed"
    ///        }
    ///      ],
    ///      "type": "object"
    ///    },
    ///    "id": {
    ///      "description": "DTO.JOB.STREAMING.ID",
    ///      "examples": [
    ///        1
    ///      ],
    ///      "type": "number"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct JobStreamingDto {
        ///DTO.JOB.STREAMING.DATA
        pub data: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
        pub id: f64,
    }
    impl ::std::convert::From<&JobStreamingDto> for JobStreamingDto {
        fn from(value: &JobStreamingDto) -> Self {
            value.clone()
        }
    }
    impl JobStreamingDto {
        pub fn builder() -> builder::JobStreamingDto {
            Default::default()
        }
    }
    ///`KytRegisterTransferRequest`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "asset",
    ///    "direction",
    ///    "network",
    ///    "transferReference"
    ///  ],
    ///  "properties": {
    ///    "asset": {
    ///      "description": "DTO.KYT.KYT_REGISTER_TRANSFER_REQUEST.ASSET",
    ///      "examples": [
    ///        "SOL"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "direction": {
    ///      "description": "DTO.KYT.KYT_REGISTER_TRANSFER_REQUEST.DIRECTION",
    ///      "examples": [
    ///        "sent"
    ///      ],
    ///      "type": "string",
    ///      "enum": [
    ///        "sent",
    ///        "received"
    ///      ]
    ///    },
    ///    "network": {
    ///      "description": "DTO.KYT.KYT_REGISTER_TRANSFER_REQUEST.NETWORK",
    ///      "examples": [
    ///        "Solana"
    ///      ],
    ///      "type": "string",
    ///      "enum": [
    ///        "bitcoin",
    ///        "ethereum",
    ///        "Solana"
    ///      ]
    ///    },
    ///    "transferReference": {
    ///      "description": "DTO.KYT.KYT_REGISTER_TRANSFER_REQUEST.TRANSFER_REFERENCE",
    ///      "examples": [
    ///        "39z5QAprVrzaFzfHu1JHPgBf9dSqYdNYhH31d3PEd4hWiWL1LML7qCct5MHGxaRAgjjj1nC3XUyLwtzGQmYqUk4y:7xfh4GGMbM3bjpWsTsmBTCfSyuvXFuqnC89fShAqk5Nj"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct KytRegisterTransferRequest {
        ///DTO.KYT.KYT_REGISTER_TRANSFER_REQUEST.ASSET
        pub asset: ::std::string::String,
        ///DTO.KYT.KYT_REGISTER_TRANSFER_REQUEST.DIRECTION
        pub direction: KytRegisterTransferRequestDirection,
        ///DTO.KYT.KYT_REGISTER_TRANSFER_REQUEST.NETWORK
        pub network: KytRegisterTransferRequestNetwork,
        ///DTO.KYT.KYT_REGISTER_TRANSFER_REQUEST.TRANSFER_REFERENCE
        #[serde(rename = "transferReference")]
        pub transfer_reference: ::std::string::String,
    }
    impl ::std::convert::From<&KytRegisterTransferRequest>
    for KytRegisterTransferRequest {
        fn from(value: &KytRegisterTransferRequest) -> Self {
            value.clone()
        }
    }
    impl KytRegisterTransferRequest {
        pub fn builder() -> builder::KytRegisterTransferRequest {
            Default::default()
        }
    }
    ///DTO.KYT.KYT_REGISTER_TRANSFER_REQUEST.DIRECTION
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "DTO.KYT.KYT_REGISTER_TRANSFER_REQUEST.DIRECTION",
    ///  "examples": [
    ///    "sent"
    ///  ],
    ///  "type": "string",
    ///  "enum": [
    ///    "sent",
    ///    "received"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum KytRegisterTransferRequestDirection {
        #[serde(rename = "sent")]
        Sent,
        #[serde(rename = "received")]
        Received,
    }
    impl ::std::convert::From<&Self> for KytRegisterTransferRequestDirection {
        fn from(value: &KytRegisterTransferRequestDirection) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for KytRegisterTransferRequestDirection {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::Sent => f.write_str("sent"),
                Self::Received => f.write_str("received"),
            }
        }
    }
    impl ::std::str::FromStr for KytRegisterTransferRequestDirection {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "sent" => Ok(Self::Sent),
                "received" => Ok(Self::Received),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for KytRegisterTransferRequestDirection {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String>
    for KytRegisterTransferRequestDirection {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String>
    for KytRegisterTransferRequestDirection {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    ///DTO.KYT.KYT_REGISTER_TRANSFER_REQUEST.NETWORK
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "DTO.KYT.KYT_REGISTER_TRANSFER_REQUEST.NETWORK",
    ///  "examples": [
    ///    "Solana"
    ///  ],
    ///  "type": "string",
    ///  "enum": [
    ///    "bitcoin",
    ///    "ethereum",
    ///    "Solana"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum KytRegisterTransferRequestNetwork {
        #[serde(rename = "bitcoin")]
        Bitcoin,
        #[serde(rename = "ethereum")]
        Ethereum,
        Solana,
    }
    impl ::std::convert::From<&Self> for KytRegisterTransferRequestNetwork {
        fn from(value: &KytRegisterTransferRequestNetwork) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for KytRegisterTransferRequestNetwork {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::Bitcoin => f.write_str("bitcoin"),
                Self::Ethereum => f.write_str("ethereum"),
                Self::Solana => f.write_str("Solana"),
            }
        }
    }
    impl ::std::str::FromStr for KytRegisterTransferRequestNetwork {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "bitcoin" => Ok(Self::Bitcoin),
                "ethereum" => Ok(Self::Ethereum),
                "Solana" => Ok(Self::Solana),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for KytRegisterTransferRequestNetwork {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String>
    for KytRegisterTransferRequestNetwork {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String>
    for KytRegisterTransferRequestNetwork {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    ///`KytRegisterWithdrawalRequest`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "address",
    ///    "asset",
    ///    "assetAmount",
    ///    "attemptTimestamp",
    ///    "network"
    ///  ],
    ///  "properties": {
    ///    "address": {
    ///      "description": "DTO.KYT.KYT_REGISTER_WITHDRAWAL_REQUEST.ADDRESS",
    ///      "examples": [
    ///        "D1Mc6j9xQWgR1o1Z7yU5nVVXFQiAYx7FG9AW1aVfwrUM"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "asset": {
    ///      "description": "DTO.KYT.KYT_REGISTER_WITHDRAWAL_REQUEST.ASSET",
    ///      "examples": [
    ///        "SOL"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "assetAmount": {
    ///      "description": "DTO.KYT.KYT_REGISTER_WITHDRAWAL_REQUEST.ASSET_AMOUNT",
    ///      "examples": [
    ///        "5"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "assetDenomination": {
    ///      "description": "DTO.KYT.KYT_REGISTER_WITHDRAWAL_REQUEST.ASSET_DENOMINATION",
    ///      "examples": [
    ///        "USD"
    ///      ],
    ///      "type": [
    ///        "string",
    ///        "null"
    ///      ]
    ///    },
    ///    "assetId": {
    ///      "description": "DTO.KYT.KYT_REGISTER_WITHDRAWAL_REQUEST.ASSET_ID",
    ///      "type": [
    ///        "string",
    ///        "null"
    ///      ]
    ///    },
    ///    "assetPrice": {
    ///      "description": "DTO.KYT.KYT_REGISTER_WITHDRAWAL_REQUEST.ASSET_PRICE",
    ///      "examples": [
    ///        "1000"
    ///      ],
    ///      "type": [
    ///        "string",
    ///        "null"
    ///      ]
    ///    },
    ///    "attemptTimestamp": {
    ///      "description": "DTO.KYT.KYT_REGISTER_WITHDRAWAL_REQUEST.ATTEMPT_TIMESTAMP",
    ///      "examples": [
    ///        "2026-01-04T17:25:40.008307"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "memo": {
    ///      "description": "DTO.KYT.KYT_REGISTER_WITHDRAWAL_REQUEST.MEMO",
    ///      "type": [
    ///        "string",
    ///        "null"
    ///      ]
    ///    },
    ///    "network": {
    ///      "description": "DTO.KYT.KYT_REGISTER_WITHDRAWAL_REQUEST.NETWORK",
    ///      "examples": [
    ///        "Solana"
    ///      ],
    ///      "type": "string",
    ///      "enum": [
    ///        "bitcoin",
    ///        "ethereum",
    ///        "Solana"
    ///      ]
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct KytRegisterWithdrawalRequest {
        ///DTO.KYT.KYT_REGISTER_WITHDRAWAL_REQUEST.ADDRESS
        pub address: ::std::string::String,
        ///DTO.KYT.KYT_REGISTER_WITHDRAWAL_REQUEST.ASSET
        pub asset: ::std::string::String,
        ///DTO.KYT.KYT_REGISTER_WITHDRAWAL_REQUEST.ASSET_AMOUNT
        #[serde(rename = "assetAmount")]
        pub asset_amount: ::std::string::String,
        ///DTO.KYT.KYT_REGISTER_WITHDRAWAL_REQUEST.ASSET_DENOMINATION
        #[serde(
            rename = "assetDenomination",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub asset_denomination: ::std::option::Option<::std::string::String>,
        ///DTO.KYT.KYT_REGISTER_WITHDRAWAL_REQUEST.ASSET_ID
        #[serde(
            rename = "assetId",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub asset_id: ::std::option::Option<::std::string::String>,
        ///DTO.KYT.KYT_REGISTER_WITHDRAWAL_REQUEST.ASSET_PRICE
        #[serde(
            rename = "assetPrice",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub asset_price: ::std::option::Option<::std::string::String>,
        ///DTO.KYT.KYT_REGISTER_WITHDRAWAL_REQUEST.ATTEMPT_TIMESTAMP
        #[serde(rename = "attemptTimestamp")]
        pub attempt_timestamp: ::std::string::String,
        ///DTO.KYT.KYT_REGISTER_WITHDRAWAL_REQUEST.MEMO
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub memo: ::std::option::Option<::std::string::String>,
        ///DTO.KYT.KYT_REGISTER_WITHDRAWAL_REQUEST.NETWORK
        pub network: KytRegisterWithdrawalRequestNetwork,
    }
    impl ::std::convert::From<&KytRegisterWithdrawalRequest>
    for KytRegisterWithdrawalRequest {
        fn from(value: &KytRegisterWithdrawalRequest) -> Self {
            value.clone()
        }
    }
    impl KytRegisterWithdrawalRequest {
        pub fn builder() -> builder::KytRegisterWithdrawalRequest {
            Default::default()
        }
    }
    ///DTO.KYT.KYT_REGISTER_WITHDRAWAL_REQUEST.NETWORK
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "DTO.KYT.KYT_REGISTER_WITHDRAWAL_REQUEST.NETWORK",
    ///  "examples": [
    ///    "Solana"
    ///  ],
    ///  "type": "string",
    ///  "enum": [
    ///    "bitcoin",
    ///    "ethereum",
    ///    "Solana"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum KytRegisterWithdrawalRequestNetwork {
        #[serde(rename = "bitcoin")]
        Bitcoin,
        #[serde(rename = "ethereum")]
        Ethereum,
        Solana,
    }
    impl ::std::convert::From<&Self> for KytRegisterWithdrawalRequestNetwork {
        fn from(value: &KytRegisterWithdrawalRequestNetwork) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for KytRegisterWithdrawalRequestNetwork {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::Bitcoin => f.write_str("bitcoin"),
                Self::Ethereum => f.write_str("ethereum"),
                Self::Solana => f.write_str("Solana"),
            }
        }
    }
    impl ::std::str::FromStr for KytRegisterWithdrawalRequestNetwork {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "bitcoin" => Ok(Self::Bitcoin),
                "ethereum" => Ok(Self::Ethereum),
                "Solana" => Ok(Self::Solana),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for KytRegisterWithdrawalRequestNetwork {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String>
    for KytRegisterWithdrawalRequestNetwork {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String>
    for KytRegisterWithdrawalRequestNetwork {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    ///`Link`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "label",
    ///    "url"
    ///  ],
    ///  "properties": {
    ///    "label": {
    ///      "description": "DTO.DEX.MOONSHOT.LINK.LABEL",
    ///      "examples": [
    ///        "Twitter"
    ///      ],
    ///      "type": "string",
    ///      "enum": [
    ///        "website",
    ///        "twitter",
    ///        "telegram",
    ///        "discord"
    ///      ]
    ///    },
    ///    "url": {
    ///      "description": "DTO.DEX.MOONSHOT.LINK.URL",
    ///      "examples": [
    ///        "https://twitter.com/tokenproject"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct Link {
        ///DTO.DEX.MOONSHOT.LINK.LABEL
        pub label: LinkLabel,
        ///DTO.DEX.MOONSHOT.LINK.URL
        pub url: ::std::string::String,
    }
    impl ::std::convert::From<&Link> for Link {
        fn from(value: &Link) -> Self {
            value.clone()
        }
    }
    impl Link {
        pub fn builder() -> builder::Link {
            Default::default()
        }
    }
    ///DTO.DEX.MOONSHOT.LINK.LABEL
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "DTO.DEX.MOONSHOT.LINK.LABEL",
    ///  "examples": [
    ///    "Twitter"
    ///  ],
    ///  "type": "string",
    ///  "enum": [
    ///    "website",
    ///    "twitter",
    ///    "telegram",
    ///    "discord"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum LinkLabel {
        #[serde(rename = "website")]
        Website,
        #[serde(rename = "twitter")]
        Twitter,
        #[serde(rename = "telegram")]
        Telegram,
        #[serde(rename = "discord")]
        Discord,
    }
    impl ::std::convert::From<&Self> for LinkLabel {
        fn from(value: &LinkLabel) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for LinkLabel {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::Website => f.write_str("website"),
                Self::Twitter => f.write_str("twitter"),
                Self::Telegram => f.write_str("telegram"),
                Self::Discord => f.write_str("discord"),
            }
        }
    }
    impl ::std::str::FromStr for LinkLabel {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "website" => Ok(Self::Website),
                "twitter" => Ok(Self::Twitter),
                "telegram" => Ok(Self::Telegram),
                "discord" => Ok(Self::Discord),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for LinkLabel {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String> for LinkLabel {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for LinkLabel {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    ///`ListEndpointsOrder`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "default": "ascending",
    ///  "type": "string",
    ///  "enum": [
    ///    "ascending",
    ///    "descending"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum ListEndpointsOrder {
        #[serde(rename = "ascending")]
        Ascending,
        #[serde(rename = "descending")]
        Descending,
    }
    impl ::std::convert::From<&Self> for ListEndpointsOrder {
        fn from(value: &ListEndpointsOrder) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for ListEndpointsOrder {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::Ascending => f.write_str("ascending"),
                Self::Descending => f.write_str("descending"),
            }
        }
    }
    impl ::std::str::FromStr for ListEndpointsOrder {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "ascending" => Ok(Self::Ascending),
                "descending" => Ok(Self::Descending),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for ListEndpointsOrder {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String> for ListEndpointsOrder {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for ListEndpointsOrder {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::default::Default for ListEndpointsOrder {
        fn default() -> Self {
            ListEndpointsOrder::Ascending
        }
    }
    ///`ListTokenDirection`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "default": "next",
    ///  "type": "string",
    ///  "enum": [
    ///    "next",
    ///    "prev"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum ListTokenDirection {
        #[serde(rename = "next")]
        Next,
        #[serde(rename = "prev")]
        Prev,
    }
    impl ::std::convert::From<&Self> for ListTokenDirection {
        fn from(value: &ListTokenDirection) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for ListTokenDirection {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::Next => f.write_str("next"),
                Self::Prev => f.write_str("prev"),
            }
        }
    }
    impl ::std::str::FromStr for ListTokenDirection {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "next" => Ok(Self::Next),
                "prev" => Ok(Self::Prev),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for ListTokenDirection {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String> for ListTokenDirection {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for ListTokenDirection {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::default::Default for ListTokenDirection {
        fn default() -> Self {
            ListTokenDirection::Next
        }
    }
    ///`ListTokenSort`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "default": "desc",
    ///  "type": "string",
    ///  "enum": [
    ///    "asc",
    ///    "desc"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum ListTokenSort {
        #[serde(rename = "asc")]
        Asc,
        #[serde(rename = "desc")]
        Desc,
    }
    impl ::std::convert::From<&Self> for ListTokenSort {
        fn from(value: &ListTokenSort) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for ListTokenSort {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::Asc => f.write_str("asc"),
                Self::Desc => f.write_str("desc"),
            }
        }
    }
    impl ::std::str::FromStr for ListTokenSort {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "asc" => Ok(Self::Asc),
                "desc" => Ok(Self::Desc),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for ListTokenSort {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String> for ListTokenSort {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for ListTokenSort {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::default::Default for ListTokenSort {
        fn default() -> Self {
            ListTokenSort::Desc
        }
    }
    ///`ListTokenSortBy`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "examples": [
    ///    "h24VolumeInUsd"
    ///  ],
    ///  "type": "string",
    ///  "enum": [
    ///    "h24VolumeInUsd",
    ///    "h24PriceChangeRatio",
    ///    "h24Buys",
    ///    "h24Sells",
    ///    "h24Trades",
    ///    "h24Buyers",
    ///    "h24Sellers",
    ///    "h24BuyVolumeInUsd",
    ///    "h24SellVolumeInUsd",
    ///    "h4VolumeInUsd",
    ///    "h4PriceChangeRatio",
    ///    "h4Buys",
    ///    "h4Sells",
    ///    "h4Trades",
    ///    "h4Buyers",
    ///    "h4Sellers",
    ///    "h4BuyVolumeInUsd",
    ///    "h4SellVolumeInUsd",
    ///    "h1VolumeInUsd",
    ///    "h1PriceChangeRatio",
    ///    "h1Buys",
    ///    "h1Sells",
    ///    "h1Trades",
    ///    "h1Buyers",
    ///    "h1Sellers",
    ///    "h1BuyVolumeInUsd",
    ///    "h1SellVolumeInUsd",
    ///    "m30VolumeInUsd",
    ///    "m30PriceChangeRatio",
    ///    "m30Buys",
    ///    "m30Sells",
    ///    "m30Trades",
    ///    "m30Buyers",
    ///    "m30Sellers",
    ///    "m30BuyVolumeInUsd",
    ///    "m30SellVolumeInUsd",
    ///    "m15VolumeInUsd",
    ///    "m15PriceChangeRatio",
    ///    "m15Buys",
    ///    "m15Sells",
    ///    "m15Trades",
    ///    "m15Buyers",
    ///    "m15Sellers",
    ///    "m15BuyVolumeInUsd",
    ///    "m15SellVolumeInUsd",
    ///    "m5VolumeInUsd",
    ///    "m5PriceChangeRatio",
    ///    "m5Buys",
    ///    "m5Sells",
    ///    "m5Trades",
    ///    "m5Buyers",
    ///    "m5Sellers",
    ///    "m5BuyVolumeInUsd",
    ///    "m5SellVolumeInUsd",
    ///    "m1VolumeInUsd",
    ///    "m1PriceChangeRatio",
    ///    "m1Buys",
    ///    "m1Sells",
    ///    "m1Trades",
    ///    "m1Buyers",
    ///    "m1Sellers",
    ///    "m1BuyVolumeInUsd",
    ///    "m1SellVolumeInUsd"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum ListTokenSortBy {
        #[serde(rename = "h24VolumeInUsd")]
        H24VolumeInUsd,
        #[serde(rename = "h24PriceChangeRatio")]
        H24PriceChangeRatio,
        #[serde(rename = "h24Buys")]
        H24Buys,
        #[serde(rename = "h24Sells")]
        H24Sells,
        #[serde(rename = "h24Trades")]
        H24Trades,
        #[serde(rename = "h24Buyers")]
        H24Buyers,
        #[serde(rename = "h24Sellers")]
        H24Sellers,
        #[serde(rename = "h24BuyVolumeInUsd")]
        H24BuyVolumeInUsd,
        #[serde(rename = "h24SellVolumeInUsd")]
        H24SellVolumeInUsd,
        #[serde(rename = "h4VolumeInUsd")]
        H4VolumeInUsd,
        #[serde(rename = "h4PriceChangeRatio")]
        H4PriceChangeRatio,
        #[serde(rename = "h4Buys")]
        H4Buys,
        #[serde(rename = "h4Sells")]
        H4Sells,
        #[serde(rename = "h4Trades")]
        H4Trades,
        #[serde(rename = "h4Buyers")]
        H4Buyers,
        #[serde(rename = "h4Sellers")]
        H4Sellers,
        #[serde(rename = "h4BuyVolumeInUsd")]
        H4BuyVolumeInUsd,
        #[serde(rename = "h4SellVolumeInUsd")]
        H4SellVolumeInUsd,
        #[serde(rename = "h1VolumeInUsd")]
        H1VolumeInUsd,
        #[serde(rename = "h1PriceChangeRatio")]
        H1PriceChangeRatio,
        #[serde(rename = "h1Buys")]
        H1Buys,
        #[serde(rename = "h1Sells")]
        H1Sells,
        #[serde(rename = "h1Trades")]
        H1Trades,
        #[serde(rename = "h1Buyers")]
        H1Buyers,
        #[serde(rename = "h1Sellers")]
        H1Sellers,
        #[serde(rename = "h1BuyVolumeInUsd")]
        H1BuyVolumeInUsd,
        #[serde(rename = "h1SellVolumeInUsd")]
        H1SellVolumeInUsd,
        #[serde(rename = "m30VolumeInUsd")]
        M30VolumeInUsd,
        #[serde(rename = "m30PriceChangeRatio")]
        M30PriceChangeRatio,
        #[serde(rename = "m30Buys")]
        M30Buys,
        #[serde(rename = "m30Sells")]
        M30Sells,
        #[serde(rename = "m30Trades")]
        M30Trades,
        #[serde(rename = "m30Buyers")]
        M30Buyers,
        #[serde(rename = "m30Sellers")]
        M30Sellers,
        #[serde(rename = "m30BuyVolumeInUsd")]
        M30BuyVolumeInUsd,
        #[serde(rename = "m30SellVolumeInUsd")]
        M30SellVolumeInUsd,
        #[serde(rename = "m15VolumeInUsd")]
        M15VolumeInUsd,
        #[serde(rename = "m15PriceChangeRatio")]
        M15PriceChangeRatio,
        #[serde(rename = "m15Buys")]
        M15Buys,
        #[serde(rename = "m15Sells")]
        M15Sells,
        #[serde(rename = "m15Trades")]
        M15Trades,
        #[serde(rename = "m15Buyers")]
        M15Buyers,
        #[serde(rename = "m15Sellers")]
        M15Sellers,
        #[serde(rename = "m15BuyVolumeInUsd")]
        M15BuyVolumeInUsd,
        #[serde(rename = "m15SellVolumeInUsd")]
        M15SellVolumeInUsd,
        #[serde(rename = "m5VolumeInUsd")]
        M5VolumeInUsd,
        #[serde(rename = "m5PriceChangeRatio")]
        M5PriceChangeRatio,
        #[serde(rename = "m5Buys")]
        M5Buys,
        #[serde(rename = "m5Sells")]
        M5Sells,
        #[serde(rename = "m5Trades")]
        M5Trades,
        #[serde(rename = "m5Buyers")]
        M5Buyers,
        #[serde(rename = "m5Sellers")]
        M5Sellers,
        #[serde(rename = "m5BuyVolumeInUsd")]
        M5BuyVolumeInUsd,
        #[serde(rename = "m5SellVolumeInUsd")]
        M5SellVolumeInUsd,
        #[serde(rename = "m1VolumeInUsd")]
        M1VolumeInUsd,
        #[serde(rename = "m1PriceChangeRatio")]
        M1PriceChangeRatio,
        #[serde(rename = "m1Buys")]
        M1Buys,
        #[serde(rename = "m1Sells")]
        M1Sells,
        #[serde(rename = "m1Trades")]
        M1Trades,
        #[serde(rename = "m1Buyers")]
        M1Buyers,
        #[serde(rename = "m1Sellers")]
        M1Sellers,
        #[serde(rename = "m1BuyVolumeInUsd")]
        M1BuyVolumeInUsd,
        #[serde(rename = "m1SellVolumeInUsd")]
        M1SellVolumeInUsd,
    }
    impl ::std::convert::From<&Self> for ListTokenSortBy {
        fn from(value: &ListTokenSortBy) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for ListTokenSortBy {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::H24VolumeInUsd => f.write_str("h24VolumeInUsd"),
                Self::H24PriceChangeRatio => f.write_str("h24PriceChangeRatio"),
                Self::H24Buys => f.write_str("h24Buys"),
                Self::H24Sells => f.write_str("h24Sells"),
                Self::H24Trades => f.write_str("h24Trades"),
                Self::H24Buyers => f.write_str("h24Buyers"),
                Self::H24Sellers => f.write_str("h24Sellers"),
                Self::H24BuyVolumeInUsd => f.write_str("h24BuyVolumeInUsd"),
                Self::H24SellVolumeInUsd => f.write_str("h24SellVolumeInUsd"),
                Self::H4VolumeInUsd => f.write_str("h4VolumeInUsd"),
                Self::H4PriceChangeRatio => f.write_str("h4PriceChangeRatio"),
                Self::H4Buys => f.write_str("h4Buys"),
                Self::H4Sells => f.write_str("h4Sells"),
                Self::H4Trades => f.write_str("h4Trades"),
                Self::H4Buyers => f.write_str("h4Buyers"),
                Self::H4Sellers => f.write_str("h4Sellers"),
                Self::H4BuyVolumeInUsd => f.write_str("h4BuyVolumeInUsd"),
                Self::H4SellVolumeInUsd => f.write_str("h4SellVolumeInUsd"),
                Self::H1VolumeInUsd => f.write_str("h1VolumeInUsd"),
                Self::H1PriceChangeRatio => f.write_str("h1PriceChangeRatio"),
                Self::H1Buys => f.write_str("h1Buys"),
                Self::H1Sells => f.write_str("h1Sells"),
                Self::H1Trades => f.write_str("h1Trades"),
                Self::H1Buyers => f.write_str("h1Buyers"),
                Self::H1Sellers => f.write_str("h1Sellers"),
                Self::H1BuyVolumeInUsd => f.write_str("h1BuyVolumeInUsd"),
                Self::H1SellVolumeInUsd => f.write_str("h1SellVolumeInUsd"),
                Self::M30VolumeInUsd => f.write_str("m30VolumeInUsd"),
                Self::M30PriceChangeRatio => f.write_str("m30PriceChangeRatio"),
                Self::M30Buys => f.write_str("m30Buys"),
                Self::M30Sells => f.write_str("m30Sells"),
                Self::M30Trades => f.write_str("m30Trades"),
                Self::M30Buyers => f.write_str("m30Buyers"),
                Self::M30Sellers => f.write_str("m30Sellers"),
                Self::M30BuyVolumeInUsd => f.write_str("m30BuyVolumeInUsd"),
                Self::M30SellVolumeInUsd => f.write_str("m30SellVolumeInUsd"),
                Self::M15VolumeInUsd => f.write_str("m15VolumeInUsd"),
                Self::M15PriceChangeRatio => f.write_str("m15PriceChangeRatio"),
                Self::M15Buys => f.write_str("m15Buys"),
                Self::M15Sells => f.write_str("m15Sells"),
                Self::M15Trades => f.write_str("m15Trades"),
                Self::M15Buyers => f.write_str("m15Buyers"),
                Self::M15Sellers => f.write_str("m15Sellers"),
                Self::M15BuyVolumeInUsd => f.write_str("m15BuyVolumeInUsd"),
                Self::M15SellVolumeInUsd => f.write_str("m15SellVolumeInUsd"),
                Self::M5VolumeInUsd => f.write_str("m5VolumeInUsd"),
                Self::M5PriceChangeRatio => f.write_str("m5PriceChangeRatio"),
                Self::M5Buys => f.write_str("m5Buys"),
                Self::M5Sells => f.write_str("m5Sells"),
                Self::M5Trades => f.write_str("m5Trades"),
                Self::M5Buyers => f.write_str("m5Buyers"),
                Self::M5Sellers => f.write_str("m5Sellers"),
                Self::M5BuyVolumeInUsd => f.write_str("m5BuyVolumeInUsd"),
                Self::M5SellVolumeInUsd => f.write_str("m5SellVolumeInUsd"),
                Self::M1VolumeInUsd => f.write_str("m1VolumeInUsd"),
                Self::M1PriceChangeRatio => f.write_str("m1PriceChangeRatio"),
                Self::M1Buys => f.write_str("m1Buys"),
                Self::M1Sells => f.write_str("m1Sells"),
                Self::M1Trades => f.write_str("m1Trades"),
                Self::M1Buyers => f.write_str("m1Buyers"),
                Self::M1Sellers => f.write_str("m1Sellers"),
                Self::M1BuyVolumeInUsd => f.write_str("m1BuyVolumeInUsd"),
                Self::M1SellVolumeInUsd => f.write_str("m1SellVolumeInUsd"),
            }
        }
    }
    impl ::std::str::FromStr for ListTokenSortBy {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "h24VolumeInUsd" => Ok(Self::H24VolumeInUsd),
                "h24PriceChangeRatio" => Ok(Self::H24PriceChangeRatio),
                "h24Buys" => Ok(Self::H24Buys),
                "h24Sells" => Ok(Self::H24Sells),
                "h24Trades" => Ok(Self::H24Trades),
                "h24Buyers" => Ok(Self::H24Buyers),
                "h24Sellers" => Ok(Self::H24Sellers),
                "h24BuyVolumeInUsd" => Ok(Self::H24BuyVolumeInUsd),
                "h24SellVolumeInUsd" => Ok(Self::H24SellVolumeInUsd),
                "h4VolumeInUsd" => Ok(Self::H4VolumeInUsd),
                "h4PriceChangeRatio" => Ok(Self::H4PriceChangeRatio),
                "h4Buys" => Ok(Self::H4Buys),
                "h4Sells" => Ok(Self::H4Sells),
                "h4Trades" => Ok(Self::H4Trades),
                "h4Buyers" => Ok(Self::H4Buyers),
                "h4Sellers" => Ok(Self::H4Sellers),
                "h4BuyVolumeInUsd" => Ok(Self::H4BuyVolumeInUsd),
                "h4SellVolumeInUsd" => Ok(Self::H4SellVolumeInUsd),
                "h1VolumeInUsd" => Ok(Self::H1VolumeInUsd),
                "h1PriceChangeRatio" => Ok(Self::H1PriceChangeRatio),
                "h1Buys" => Ok(Self::H1Buys),
                "h1Sells" => Ok(Self::H1Sells),
                "h1Trades" => Ok(Self::H1Trades),
                "h1Buyers" => Ok(Self::H1Buyers),
                "h1Sellers" => Ok(Self::H1Sellers),
                "h1BuyVolumeInUsd" => Ok(Self::H1BuyVolumeInUsd),
                "h1SellVolumeInUsd" => Ok(Self::H1SellVolumeInUsd),
                "m30VolumeInUsd" => Ok(Self::M30VolumeInUsd),
                "m30PriceChangeRatio" => Ok(Self::M30PriceChangeRatio),
                "m30Buys" => Ok(Self::M30Buys),
                "m30Sells" => Ok(Self::M30Sells),
                "m30Trades" => Ok(Self::M30Trades),
                "m30Buyers" => Ok(Self::M30Buyers),
                "m30Sellers" => Ok(Self::M30Sellers),
                "m30BuyVolumeInUsd" => Ok(Self::M30BuyVolumeInUsd),
                "m30SellVolumeInUsd" => Ok(Self::M30SellVolumeInUsd),
                "m15VolumeInUsd" => Ok(Self::M15VolumeInUsd),
                "m15PriceChangeRatio" => Ok(Self::M15PriceChangeRatio),
                "m15Buys" => Ok(Self::M15Buys),
                "m15Sells" => Ok(Self::M15Sells),
                "m15Trades" => Ok(Self::M15Trades),
                "m15Buyers" => Ok(Self::M15Buyers),
                "m15Sellers" => Ok(Self::M15Sellers),
                "m15BuyVolumeInUsd" => Ok(Self::M15BuyVolumeInUsd),
                "m15SellVolumeInUsd" => Ok(Self::M15SellVolumeInUsd),
                "m5VolumeInUsd" => Ok(Self::M5VolumeInUsd),
                "m5PriceChangeRatio" => Ok(Self::M5PriceChangeRatio),
                "m5Buys" => Ok(Self::M5Buys),
                "m5Sells" => Ok(Self::M5Sells),
                "m5Trades" => Ok(Self::M5Trades),
                "m5Buyers" => Ok(Self::M5Buyers),
                "m5Sellers" => Ok(Self::M5Sellers),
                "m5BuyVolumeInUsd" => Ok(Self::M5BuyVolumeInUsd),
                "m5SellVolumeInUsd" => Ok(Self::M5SellVolumeInUsd),
                "m1VolumeInUsd" => Ok(Self::M1VolumeInUsd),
                "m1PriceChangeRatio" => Ok(Self::M1PriceChangeRatio),
                "m1Buys" => Ok(Self::M1Buys),
                "m1Sells" => Ok(Self::M1Sells),
                "m1Trades" => Ok(Self::M1Trades),
                "m1Buyers" => Ok(Self::M1Buyers),
                "m1Sellers" => Ok(Self::M1Sellers),
                "m1BuyVolumeInUsd" => Ok(Self::M1BuyVolumeInUsd),
                "m1SellVolumeInUsd" => Ok(Self::M1SellVolumeInUsd),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for ListTokenSortBy {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String> for ListTokenSortBy {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for ListTokenSortBy {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    ///`MoonshotCreateTokenInput`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "description",
    ///    "dex",
    ///    "icon",
    ///    "links",
    ///    "migrationDex",
    ///    "name",
    ///    "symbol",
    ///    "tokenAmount",
    ///    "userAddress"
    ///  ],
    ///  "properties": {
    ///    "banner": {
    ///      "description": "DTO.DEX.MOONSHOT.MINT.BANNER",
    ///      "examples": [
    ///        "https://assets.mytoken.com/banner.png"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "description": {
    ///      "description": "DTO.DEX.MOONSHOT.MINT.DESCRIPTION",
    ///      "examples": [
    ///        "A revolutionary new token for the Solana ecosystem"
    ///      ],
    ///      "type": "string",
    ///      "maxLength": 1000
    ///    },
    ///    "dex": {
    ///      "description": "DTO.DEX.IDENTIFIER",
    ///      "examples": [
    ///        "moonshot"
    ///      ],
    ///      "type": "string",
    ///      "enum": [
    ///        "moonshot"
    ///      ]
    ///    },
    ///    "icon": {
    ///      "description": "DTO.DEX.MOONSHOT.MINT.ICON",
    ///      "examples": [
    ///        "https://assets.mytoken.com/icon.png"
    ///      ],
    ///      "type": "string",
    ///      "pattern": "^(https?://|data:image/)"
    ///    },
    ///    "links": {
    ///      "description": "DTO.DEX.MOONSHOT.MINT.LINKS",
    ///      "type": "array",
    ///      "items": {
    ///        "$ref": "#/components/schemas/Link"
    ///      }
    ///    },
    ///    "migrationDex": {
    ///      "description": "DTO.DEX.MOONSHOT.MINT.MIGRATION_DEX",
    ///      "examples": [
    ///        "RAYDIUM"
    ///      ],
    ///      "type": "string",
    ///      "enum": [
    ///        "RAYDIUM",
    ///        "METEORA",
    ///        "UNISWAP"
    ///      ]
    ///    },
    ///    "name": {
    ///      "description": "DTO.DEX.MOONSHOT.MINT.NAME",
    ///      "examples": [
    ///        "My Token"
    ///      ],
    ///      "type": "string",
    ///      "maxLength": 32,
    ///      "minLength": 1
    ///    },
    ///    "priorityFee": {
    ///      "description": "DTO.DEX.BASE.PRIORITY_FEE",
    ///      "examples": [
    ///        "1000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "symbol": {
    ///      "description": "DTO.DEX.MOONSHOT.MINT.SYMBOL",
    ///      "examples": [
    ///        "MTK"
    ///      ],
    ///      "type": "string",
    ///      "maxLength": 10,
    ///      "minLength": 1
    ///    },
    ///    "tokenAmount": {
    ///      "description": "DTO.DEX.MOONSHOT.MINT.TOKEN_AMOUNT",
    ///      "examples": [
    ///        "1000000000"
    ///      ],
    ///      "type": "string",
    ///      "pattern": "^[0-9]+$"
    ///    },
    ///    "userAddress": {
    ///      "description": "DTO.DEX.WALLET",
    ///      "examples": [
    ///        "oQPnhXAbLbMuKHESaGrbXT17CyvWCpLyERSJA9HCYd7"
    ///      ],
    ///      "type": "string",
    ///      "maxLength": 64,
    ///      "minLength": 8
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct MoonshotCreateTokenInput {
        ///DTO.DEX.MOONSHOT.MINT.BANNER
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub banner: ::std::option::Option<::std::string::String>,
        ///DTO.DEX.MOONSHOT.MINT.DESCRIPTION
        pub description: MoonshotCreateTokenInputDescription,
        ///DTO.DEX.IDENTIFIER
        pub dex: MoonshotCreateTokenInputDex,
        ///DTO.DEX.MOONSHOT.MINT.ICON
        pub icon: MoonshotCreateTokenInputIcon,
        ///DTO.DEX.MOONSHOT.MINT.LINKS
        pub links: ::std::vec::Vec<Link>,
        ///DTO.DEX.MOONSHOT.MINT.MIGRATION_DEX
        #[serde(rename = "migrationDex")]
        pub migration_dex: MoonshotCreateTokenInputMigrationDex,
        ///DTO.DEX.MOONSHOT.MINT.NAME
        pub name: MoonshotCreateTokenInputName,
        ///DTO.DEX.BASE.PRIORITY_FEE
        #[serde(
            rename = "priorityFee",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub priority_fee: ::std::option::Option<::std::string::String>,
        ///DTO.DEX.MOONSHOT.MINT.SYMBOL
        pub symbol: MoonshotCreateTokenInputSymbol,
        ///DTO.DEX.MOONSHOT.MINT.TOKEN_AMOUNT
        #[serde(rename = "tokenAmount")]
        pub token_amount: MoonshotCreateTokenInputTokenAmount,
        ///DTO.DEX.WALLET
        #[serde(rename = "userAddress")]
        pub user_address: MoonshotCreateTokenInputUserAddress,
    }
    impl ::std::convert::From<&MoonshotCreateTokenInput> for MoonshotCreateTokenInput {
        fn from(value: &MoonshotCreateTokenInput) -> Self {
            value.clone()
        }
    }
    impl MoonshotCreateTokenInput {
        pub fn builder() -> builder::MoonshotCreateTokenInput {
            Default::default()
        }
    }
    ///DTO.DEX.MOONSHOT.MINT.DESCRIPTION
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "DTO.DEX.MOONSHOT.MINT.DESCRIPTION",
    ///  "examples": [
    ///    "A revolutionary new token for the Solana ecosystem"
    ///  ],
    ///  "type": "string",
    ///  "maxLength": 1000
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
    #[serde(transparent)]
    pub struct MoonshotCreateTokenInputDescription(::std::string::String);
    impl ::std::ops::Deref for MoonshotCreateTokenInputDescription {
        type Target = ::std::string::String;
        fn deref(&self) -> &::std::string::String {
            &self.0
        }
    }
    impl ::std::convert::From<MoonshotCreateTokenInputDescription>
    for ::std::string::String {
        fn from(value: MoonshotCreateTokenInputDescription) -> Self {
            value.0
        }
    }
    impl ::std::convert::From<&MoonshotCreateTokenInputDescription>
    for MoonshotCreateTokenInputDescription {
        fn from(value: &MoonshotCreateTokenInputDescription) -> Self {
            value.clone()
        }
    }
    impl ::std::str::FromStr for MoonshotCreateTokenInputDescription {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            if value.chars().count() > 1000usize {
                return Err("longer than 1000 characters".into());
            }
            Ok(Self(value.to_string()))
        }
    }
    impl ::std::convert::TryFrom<&str> for MoonshotCreateTokenInputDescription {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String>
    for MoonshotCreateTokenInputDescription {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String>
    for MoonshotCreateTokenInputDescription {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl<'de> ::serde::Deserialize<'de> for MoonshotCreateTokenInputDescription {
        fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
        where
            D: ::serde::Deserializer<'de>,
        {
            ::std::string::String::deserialize(deserializer)?
                .parse()
                .map_err(|e: self::error::ConversionError| {
                    <D::Error as ::serde::de::Error>::custom(e.to_string())
                })
        }
    }
    ///DTO.DEX.IDENTIFIER
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "DTO.DEX.IDENTIFIER",
    ///  "examples": [
    ///    "moonshot"
    ///  ],
    ///  "type": "string",
    ///  "enum": [
    ///    "moonshot"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum MoonshotCreateTokenInputDex {
        #[serde(rename = "moonshot")]
        Moonshot,
    }
    impl ::std::convert::From<&Self> for MoonshotCreateTokenInputDex {
        fn from(value: &MoonshotCreateTokenInputDex) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for MoonshotCreateTokenInputDex {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::Moonshot => f.write_str("moonshot"),
            }
        }
    }
    impl ::std::str::FromStr for MoonshotCreateTokenInputDex {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "moonshot" => Ok(Self::Moonshot),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for MoonshotCreateTokenInputDex {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String>
    for MoonshotCreateTokenInputDex {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for MoonshotCreateTokenInputDex {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    ///DTO.DEX.MOONSHOT.MINT.ICON
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "DTO.DEX.MOONSHOT.MINT.ICON",
    ///  "examples": [
    ///    "https://assets.mytoken.com/icon.png"
    ///  ],
    ///  "type": "string",
    ///  "pattern": "^(https?://|data:image/)"
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
    #[serde(transparent)]
    pub struct MoonshotCreateTokenInputIcon(::std::string::String);
    impl ::std::ops::Deref for MoonshotCreateTokenInputIcon {
        type Target = ::std::string::String;
        fn deref(&self) -> &::std::string::String {
            &self.0
        }
    }
    impl ::std::convert::From<MoonshotCreateTokenInputIcon> for ::std::string::String {
        fn from(value: MoonshotCreateTokenInputIcon) -> Self {
            value.0
        }
    }
    impl ::std::convert::From<&MoonshotCreateTokenInputIcon>
    for MoonshotCreateTokenInputIcon {
        fn from(value: &MoonshotCreateTokenInputIcon) -> Self {
            value.clone()
        }
    }
    impl ::std::str::FromStr for MoonshotCreateTokenInputIcon {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            static PATTERN: ::std::sync::LazyLock<::regress::Regex> = ::std::sync::LazyLock::new(||
            { ::regress::Regex::new("^(https?://|data:image/)").unwrap() });
            if PATTERN.find(value).is_none() {
                return Err("doesn't match pattern \"^(https?://|data:image/)\"".into());
            }
            Ok(Self(value.to_string()))
        }
    }
    impl ::std::convert::TryFrom<&str> for MoonshotCreateTokenInputIcon {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String>
    for MoonshotCreateTokenInputIcon {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String>
    for MoonshotCreateTokenInputIcon {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl<'de> ::serde::Deserialize<'de> for MoonshotCreateTokenInputIcon {
        fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
        where
            D: ::serde::Deserializer<'de>,
        {
            ::std::string::String::deserialize(deserializer)?
                .parse()
                .map_err(|e: self::error::ConversionError| {
                    <D::Error as ::serde::de::Error>::custom(e.to_string())
                })
        }
    }
    ///DTO.DEX.MOONSHOT.MINT.MIGRATION_DEX
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "DTO.DEX.MOONSHOT.MINT.MIGRATION_DEX",
    ///  "examples": [
    ///    "RAYDIUM"
    ///  ],
    ///  "type": "string",
    ///  "enum": [
    ///    "RAYDIUM",
    ///    "METEORA",
    ///    "UNISWAP"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum MoonshotCreateTokenInputMigrationDex {
        #[serde(rename = "RAYDIUM")]
        Raydium,
        #[serde(rename = "METEORA")]
        Meteora,
        #[serde(rename = "UNISWAP")]
        Uniswap,
    }
    impl ::std::convert::From<&Self> for MoonshotCreateTokenInputMigrationDex {
        fn from(value: &MoonshotCreateTokenInputMigrationDex) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for MoonshotCreateTokenInputMigrationDex {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::Raydium => f.write_str("RAYDIUM"),
                Self::Meteora => f.write_str("METEORA"),
                Self::Uniswap => f.write_str("UNISWAP"),
            }
        }
    }
    impl ::std::str::FromStr for MoonshotCreateTokenInputMigrationDex {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "RAYDIUM" => Ok(Self::Raydium),
                "METEORA" => Ok(Self::Meteora),
                "UNISWAP" => Ok(Self::Uniswap),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for MoonshotCreateTokenInputMigrationDex {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String>
    for MoonshotCreateTokenInputMigrationDex {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String>
    for MoonshotCreateTokenInputMigrationDex {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    ///DTO.DEX.MOONSHOT.MINT.NAME
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "DTO.DEX.MOONSHOT.MINT.NAME",
    ///  "examples": [
    ///    "My Token"
    ///  ],
    ///  "type": "string",
    ///  "maxLength": 32,
    ///  "minLength": 1
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
    #[serde(transparent)]
    pub struct MoonshotCreateTokenInputName(::std::string::String);
    impl ::std::ops::Deref for MoonshotCreateTokenInputName {
        type Target = ::std::string::String;
        fn deref(&self) -> &::std::string::String {
            &self.0
        }
    }
    impl ::std::convert::From<MoonshotCreateTokenInputName> for ::std::string::String {
        fn from(value: MoonshotCreateTokenInputName) -> Self {
            value.0
        }
    }
    impl ::std::convert::From<&MoonshotCreateTokenInputName>
    for MoonshotCreateTokenInputName {
        fn from(value: &MoonshotCreateTokenInputName) -> Self {
            value.clone()
        }
    }
    impl ::std::str::FromStr for MoonshotCreateTokenInputName {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            if value.chars().count() > 32usize {
                return Err("longer than 32 characters".into());
            }
            if value.chars().count() < 1usize {
                return Err("shorter than 1 characters".into());
            }
            Ok(Self(value.to_string()))
        }
    }
    impl ::std::convert::TryFrom<&str> for MoonshotCreateTokenInputName {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String>
    for MoonshotCreateTokenInputName {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String>
    for MoonshotCreateTokenInputName {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl<'de> ::serde::Deserialize<'de> for MoonshotCreateTokenInputName {
        fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
        where
            D: ::serde::Deserializer<'de>,
        {
            ::std::string::String::deserialize(deserializer)?
                .parse()
                .map_err(|e: self::error::ConversionError| {
                    <D::Error as ::serde::de::Error>::custom(e.to_string())
                })
        }
    }
    ///DTO.DEX.MOONSHOT.MINT.SYMBOL
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "DTO.DEX.MOONSHOT.MINT.SYMBOL",
    ///  "examples": [
    ///    "MTK"
    ///  ],
    ///  "type": "string",
    ///  "maxLength": 10,
    ///  "minLength": 1
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
    #[serde(transparent)]
    pub struct MoonshotCreateTokenInputSymbol(::std::string::String);
    impl ::std::ops::Deref for MoonshotCreateTokenInputSymbol {
        type Target = ::std::string::String;
        fn deref(&self) -> &::std::string::String {
            &self.0
        }
    }
    impl ::std::convert::From<MoonshotCreateTokenInputSymbol> for ::std::string::String {
        fn from(value: MoonshotCreateTokenInputSymbol) -> Self {
            value.0
        }
    }
    impl ::std::convert::From<&MoonshotCreateTokenInputSymbol>
    for MoonshotCreateTokenInputSymbol {
        fn from(value: &MoonshotCreateTokenInputSymbol) -> Self {
            value.clone()
        }
    }
    impl ::std::str::FromStr for MoonshotCreateTokenInputSymbol {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            if value.chars().count() > 10usize {
                return Err("longer than 10 characters".into());
            }
            if value.chars().count() < 1usize {
                return Err("shorter than 1 characters".into());
            }
            Ok(Self(value.to_string()))
        }
    }
    impl ::std::convert::TryFrom<&str> for MoonshotCreateTokenInputSymbol {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String>
    for MoonshotCreateTokenInputSymbol {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String>
    for MoonshotCreateTokenInputSymbol {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl<'de> ::serde::Deserialize<'de> for MoonshotCreateTokenInputSymbol {
        fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
        where
            D: ::serde::Deserializer<'de>,
        {
            ::std::string::String::deserialize(deserializer)?
                .parse()
                .map_err(|e: self::error::ConversionError| {
                    <D::Error as ::serde::de::Error>::custom(e.to_string())
                })
        }
    }
    ///DTO.DEX.MOONSHOT.MINT.TOKEN_AMOUNT
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "DTO.DEX.MOONSHOT.MINT.TOKEN_AMOUNT",
    ///  "examples": [
    ///    "1000000000"
    ///  ],
    ///  "type": "string",
    ///  "pattern": "^[0-9]+$"
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
    #[serde(transparent)]
    pub struct MoonshotCreateTokenInputTokenAmount(::std::string::String);
    impl ::std::ops::Deref for MoonshotCreateTokenInputTokenAmount {
        type Target = ::std::string::String;
        fn deref(&self) -> &::std::string::String {
            &self.0
        }
    }
    impl ::std::convert::From<MoonshotCreateTokenInputTokenAmount>
    for ::std::string::String {
        fn from(value: MoonshotCreateTokenInputTokenAmount) -> Self {
            value.0
        }
    }
    impl ::std::convert::From<&MoonshotCreateTokenInputTokenAmount>
    for MoonshotCreateTokenInputTokenAmount {
        fn from(value: &MoonshotCreateTokenInputTokenAmount) -> Self {
            value.clone()
        }
    }
    impl ::std::str::FromStr for MoonshotCreateTokenInputTokenAmount {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            static PATTERN: ::std::sync::LazyLock<::regress::Regex> = ::std::sync::LazyLock::new(||
            { ::regress::Regex::new("^[0-9]+$").unwrap() });
            if PATTERN.find(value).is_none() {
                return Err("doesn't match pattern \"^[0-9]+$\"".into());
            }
            Ok(Self(value.to_string()))
        }
    }
    impl ::std::convert::TryFrom<&str> for MoonshotCreateTokenInputTokenAmount {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String>
    for MoonshotCreateTokenInputTokenAmount {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String>
    for MoonshotCreateTokenInputTokenAmount {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl<'de> ::serde::Deserialize<'de> for MoonshotCreateTokenInputTokenAmount {
        fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
        where
            D: ::serde::Deserializer<'de>,
        {
            ::std::string::String::deserialize(deserializer)?
                .parse()
                .map_err(|e: self::error::ConversionError| {
                    <D::Error as ::serde::de::Error>::custom(e.to_string())
                })
        }
    }
    ///DTO.DEX.WALLET
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "DTO.DEX.WALLET",
    ///  "examples": [
    ///    "oQPnhXAbLbMuKHESaGrbXT17CyvWCpLyERSJA9HCYd7"
    ///  ],
    ///  "type": "string",
    ///  "maxLength": 64,
    ///  "minLength": 8
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
    #[serde(transparent)]
    pub struct MoonshotCreateTokenInputUserAddress(::std::string::String);
    impl ::std::ops::Deref for MoonshotCreateTokenInputUserAddress {
        type Target = ::std::string::String;
        fn deref(&self) -> &::std::string::String {
            &self.0
        }
    }
    impl ::std::convert::From<MoonshotCreateTokenInputUserAddress>
    for ::std::string::String {
        fn from(value: MoonshotCreateTokenInputUserAddress) -> Self {
            value.0
        }
    }
    impl ::std::convert::From<&MoonshotCreateTokenInputUserAddress>
    for MoonshotCreateTokenInputUserAddress {
        fn from(value: &MoonshotCreateTokenInputUserAddress) -> Self {
            value.clone()
        }
    }
    impl ::std::str::FromStr for MoonshotCreateTokenInputUserAddress {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            if value.chars().count() > 64usize {
                return Err("longer than 64 characters".into());
            }
            if value.chars().count() < 8usize {
                return Err("shorter than 8 characters".into());
            }
            Ok(Self(value.to_string()))
        }
    }
    impl ::std::convert::TryFrom<&str> for MoonshotCreateTokenInputUserAddress {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String>
    for MoonshotCreateTokenInputUserAddress {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String>
    for MoonshotCreateTokenInputUserAddress {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl<'de> ::serde::Deserialize<'de> for MoonshotCreateTokenInputUserAddress {
        fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
        where
            D: ::serde::Deserializer<'de>,
        {
            ::std::string::String::deserialize(deserializer)?
                .parse()
                .map_err(|e: self::error::ConversionError| {
                    <D::Error as ::serde::de::Error>::custom(e.to_string())
                })
        }
    }
    ///`MoonshotCreateTokenReply`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "extra",
    ///    "serializedTx"
    ///  ],
    ///  "properties": {
    ///    "extra": {
    ///      "description": "DTO.DEX.MOONSHOT.CREATE_TOKEN.EXTRA",
    ///      "examples": [
    ///        {
    ///          "token": {
    ///            "address": "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA",
    ///            "decimals": 9
    ///          },
    ///          "tokenId": "token_123456"
    ///        }
    ///      ],
    ///      "type": "object"
    ///    },
    ///    "serializedTx": {
    ///      "description": "DTO.DEX.MOONSHOT.CREATE_TOKEN.SERIALIZED_TX",
    ///      "examples": [
    ///        "AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAEDRgYGpQEDAQIABQcICQoLDA0ODwAAAAAAAAAAAAAQERITFBUWFxgZGhscHR4fAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA="
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct MoonshotCreateTokenReply {
        ///DTO.DEX.MOONSHOT.CREATE_TOKEN.EXTRA
        pub extra: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
        ///DTO.DEX.MOONSHOT.CREATE_TOKEN.SERIALIZED_TX
        #[serde(rename = "serializedTx")]
        pub serialized_tx: ::std::string::String,
    }
    impl ::std::convert::From<&MoonshotCreateTokenReply> for MoonshotCreateTokenReply {
        fn from(value: &MoonshotCreateTokenReply) -> Self {
            value.clone()
        }
    }
    impl MoonshotCreateTokenReply {
        pub fn builder() -> builder::MoonshotCreateTokenReply {
            Default::default()
        }
    }
    ///`MoonshotSubmitCreateTokenInput`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "signedTx"
    ///  ],
    ///  "properties": {
    ///    "extra": {
    ///      "description": "DTO.DEX.MOONSHOT.SUBMIT.CREATE_TOKEN.EXTRA",
    ///      "examples": [
    ///        {
    ///          "token": {
    ///            "address": "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA",
    ///            "decimals": 9
    ///          },
    ///          "tokenId": "token_123456"
    ///        }
    ///      ],
    ///      "type": "object"
    ///    },
    ///    "signedTx": {
    ///      "description": "DTO.DEX.MOONSHOT.SUBMIT.CREATE_TOKEN.SIGNED_TX",
    ///      "examples": [
    ///        "AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAEDRgYGpQEDAQIABQcICQoLDA0ODwAAAAAAAAAAAAAQERITFBUWFxgZGhscHR4fAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA="
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct MoonshotSubmitCreateTokenInput {
        ///DTO.DEX.MOONSHOT.SUBMIT.CREATE_TOKEN.EXTRA
        #[serde(default, skip_serializing_if = "::serde_json::Map::is_empty")]
        pub extra: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
        ///DTO.DEX.MOONSHOT.SUBMIT.CREATE_TOKEN.SIGNED_TX
        #[serde(rename = "signedTx")]
        pub signed_tx: ::std::string::String,
    }
    impl ::std::convert::From<&MoonshotSubmitCreateTokenInput>
    for MoonshotSubmitCreateTokenInput {
        fn from(value: &MoonshotSubmitCreateTokenInput) -> Self {
            value.clone()
        }
    }
    impl MoonshotSubmitCreateTokenInput {
        pub fn builder() -> builder::MoonshotSubmitCreateTokenInput {
            Default::default()
        }
    }
    ///`MoonshotSubmitCreateTokenResponse`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "properties": {
    ///    "signature": {
    ///      "description": "Transaction signature",
    ///      "examples": [
    ///        "5KtPn1LGuxhFiwjxEqHRGrXJZ8wFzNqsV8DYjPZmxhVGwpEgKcdd9dGxPAzEqLXZ9QyjZvxHfYK9QqSf8EGtK4P5"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "slot": {
    ///      "description": "Block slot number",
    ///      "examples": [
    ///        234506754
    ///      ],
    ///      "type": "number"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct MoonshotSubmitCreateTokenResponse {
        ///Transaction signature
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub signature: ::std::option::Option<::std::string::String>,
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub slot: ::std::option::Option<f64>,
    }
    impl ::std::convert::From<&MoonshotSubmitCreateTokenResponse>
    for MoonshotSubmitCreateTokenResponse {
        fn from(value: &MoonshotSubmitCreateTokenResponse) -> Self {
            value.clone()
        }
    }
    impl ::std::default::Default for MoonshotSubmitCreateTokenResponse {
        fn default() -> Self {
            Self {
                signature: Default::default(),
                slot: Default::default(),
            }
        }
    }
    impl MoonshotSubmitCreateTokenResponse {
        pub fn builder() -> builder::MoonshotSubmitCreateTokenResponse {
            Default::default()
        }
    }
    ///`NetworkIdentificationOrg`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "name"
    ///  ],
    ///  "properties": {
    ///    "name": {
    ///      "description": "DTO.KYT.NETWORK_IDENTIFICATION_ORG.NAME",
    ///      "examples": [
    ///        "XYZ Cryptocurrency Exchange"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct NetworkIdentificationOrg {
        ///DTO.KYT.NETWORK_IDENTIFICATION_ORG.NAME
        pub name: ::std::string::String,
    }
    impl ::std::convert::From<&NetworkIdentificationOrg> for NetworkIdentificationOrg {
        fn from(value: &NetworkIdentificationOrg) -> Self {
            value.clone()
        }
    }
    impl NetworkIdentificationOrg {
        pub fn builder() -> builder::NetworkIdentificationOrg {
            Default::default()
        }
    }
    ///`OnChainActivity`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "first_transaction_at"
    ///  ],
    ///  "properties": {
    ///    "first_transaction_at": {
    ///      "description": "DTO.KYT.ON_CHAIN_ACTIVITY.FIRST_TRANSACTION_AT",
    ///      "examples": [
    ///        1724317680000
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct OnChainActivity {
        ///DTO.KYT.ON_CHAIN_ACTIVITY.FIRST_TRANSACTION_AT
        pub first_transaction_at: i64,
    }
    impl ::std::convert::From<&OnChainActivity> for OnChainActivity {
        fn from(value: &OnChainActivity) -> Self {
            value.clone()
        }
    }
    impl OnChainActivity {
        pub fn builder() -> builder::OnChainActivity {
            Default::default()
        }
    }
    ///`PnlDetailItemDto`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "avgBuyPriceInUsd",
    ///    "avgProfitPerTradeInUsd",
    ///    "avgSellPriceInUsd",
    ///    "balance",
    ///    "buyAmount",
    ///    "buyAmountInUsd",
    ///    "buys",
    ///    "currentValue",
    ///    "decimals",
    ///    "name",
    ///    "priceInUsd",
    ///    "realizedProfitInUsd",
    ///    "realizedProfitRatio",
    ///    "sellAmount",
    ///    "sellAmountInUsd",
    ///    "sells",
    ///    "symbol",
    ///    "tokenAddress",
    ///    "totalProfitInUsd",
    ///    "totalProfitRatio",
    ///    "totalTrades",
    ///    "unrealizedProfitInUsd",
    ///    "unrealizedProfitRatio",
    ///    "walletAddress"
    ///  ],
    ///  "properties": {
    ///    "avgBuyPriceInUsd": {
    ///      "description": "DTO.WALLET.PNL_DETAIL.ITEM.AVG_BUY_PRICE_IN_USD",
    ///      "examples": [
    ///        "0.0000332439"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "avgProfitPerTradeInUsd": {
    ///      "description": "DTO.WALLET.PNL_DETAIL.ITEM.AVG_PROFIT_PER_TRADE_IN_USD",
    ///      "examples": [
    ///        "3205025.72"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "avgSellPriceInUsd": {
    ///      "description": "DTO.WALLET.PNL_DETAIL.ITEM.AVG_SELL_PRICE_IN_USD",
    ///      "examples": [
    ///        "0.0000318580"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "balance": {
    ///      "description": "DTO.WALLET.PNL_DETAIL.ITEM.BALANCE",
    ///      "examples": [
    ///        "1254982158.71"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "buyAmount": {
    ///      "description": "DTO.WALLET.PNL_DETAIL.ITEM.BUY_AMOUNT",
    ///      "examples": [
    ///        "1457986404.21"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "buyAmountInUsd": {
    ///      "description": "DTO.WALLET.PNL_DETAIL.ITEM.BUY_AMOUNT_IN_USD",
    ///      "examples": [
    ///        "48469.17"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "buys": {
    ///      "description": "DTO.WALLET.PNL_DETAIL.ITEM.BUYS",
    ///      "examples": [
    ///        "275"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "currentValue": {
    ///      "description": "DTO.WALLET.PNL_DETAIL.ITEM.CURRENT_VALUE",
    ///      "examples": [
    ///        "1062547123.45"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "decimals": {
    ///      "description": "DTO.WALLET.PNL_DETAIL.ITEM.DECIMALS",
    ///      "examples": [
    ///        9
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "logoUri": {
    ///      "description": "DTO.WALLET.PNL_DETAIL.ITEM.LOGO_URI",
    ///      "examples": [
    ///        "https://..."
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "name": {
    ///      "description": "DTO.WALLET.PNL_DETAIL.ITEM.NAME",
    ///      "examples": [
    ///        "Solana"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "priceInUsd": {
    ///      "description": "DTO.WALLET.PNL_DETAIL.ITEM.PRICE_IN_USD",
    ///      "examples": [
    ///        "0.8466367032"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "realizedProfitInUsd": {
    ///      "description": "DTO.WALLET.PNL_DETAIL.ITEM.REALIZED_PROFIT_IN_USD",
    ///      "examples": [
    ///        "67.13"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "realizedProfitRatio": {
    ///      "description": "DTO.WALLET.PNL_DETAIL.ITEM.REALIZED_PROFIT_RATIO",
    ///      "examples": [
    ///        "0.0013849997"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "sellAmount": {
    ///      "description": "DTO.WALLET.PNL_DETAIL.ITEM.SELL_AMOUNT",
    ///      "examples": [
    ///        "203004245.50"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "sellAmountInUsd": {
    ///      "description": "DTO.WALLET.PNL_DETAIL.ITEM.SELL_AMOUNT_IN_USD",
    ///      "examples": [
    ///        "6467.32"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "sells": {
    ///      "description": "DTO.WALLET.PNL_DETAIL.ITEM.SELLS",
    ///      "examples": [
    ///        "110"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "symbol": {
    ///      "description": "DTO.WALLET.PNL_DETAIL.ITEM.SYMBOL",
    ///      "examples": [
    ///        "SOL"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "tokenAddress": {
    ///      "description": "DTO.WALLET.PNL_DETAIL.ITEM.TOKEN_ADDRESS",
    ///      "examples": [
    ///        "4MbgMQGvXBWyxKsTfrvkcRgh5FNLg1VxLnzWqbsdPh7p"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "totalProfitInUsd": {
    ///      "description": "DTO.WALLET.PNL_DETAIL.ITEM.TOTAL_PROFIT_IN_USD",
    ///      "examples": [
    ///        "1234336400.54"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "totalProfitRatio": {
    ///      "description": "DTO.WALLET.PNL_DETAIL.ITEM.TOTAL_PROFIT_RATIO",
    ///      "examples": [
    ///        "25466.42"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "totalTrades": {
    ///      "description": "DTO.WALLET.PNL_DETAIL.ITEM.TOTAL_TRADES",
    ///      "examples": [
    ///        "385"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "unrealizedProfitInUsd": {
    ///      "description": "DTO.WALLET.PNL_DETAIL.ITEM.UNREALIZED_PROFIT_IN_USD",
    ///      "examples": [
    ///        "1234336333.41"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "unrealizedProfitRatio": {
    ///      "description": "DTO.WALLET.PNL_DETAIL.ITEM.UNREALIZED_PROFIT_RATIO",
    ///      "examples": [
    ///        "25466.42"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "walletAddress": {
    ///      "description": "DTO.WALLET.PNL_DETAIL.ITEM.WALLET_ADDRESS",
    ///      "examples": [
    ///        "54Pz1e35z9uoFdnxtzjp7xZQoFiofqhdayQWBMN7dsuy"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct PnlDetailItemDto {
        ///DTO.WALLET.PNL_DETAIL.ITEM.AVG_BUY_PRICE_IN_USD
        #[serde(rename = "avgBuyPriceInUsd")]
        pub avg_buy_price_in_usd: ::std::string::String,
        ///DTO.WALLET.PNL_DETAIL.ITEM.AVG_PROFIT_PER_TRADE_IN_USD
        #[serde(rename = "avgProfitPerTradeInUsd")]
        pub avg_profit_per_trade_in_usd: ::std::string::String,
        ///DTO.WALLET.PNL_DETAIL.ITEM.AVG_SELL_PRICE_IN_USD
        #[serde(rename = "avgSellPriceInUsd")]
        pub avg_sell_price_in_usd: ::std::string::String,
        ///DTO.WALLET.PNL_DETAIL.ITEM.BALANCE
        pub balance: ::std::string::String,
        ///DTO.WALLET.PNL_DETAIL.ITEM.BUY_AMOUNT
        #[serde(rename = "buyAmount")]
        pub buy_amount: ::std::string::String,
        ///DTO.WALLET.PNL_DETAIL.ITEM.BUY_AMOUNT_IN_USD
        #[serde(rename = "buyAmountInUsd")]
        pub buy_amount_in_usd: ::std::string::String,
        ///DTO.WALLET.PNL_DETAIL.ITEM.BUYS
        pub buys: ::std::string::String,
        ///DTO.WALLET.PNL_DETAIL.ITEM.CURRENT_VALUE
        #[serde(rename = "currentValue")]
        pub current_value: ::std::string::String,
        ///DTO.WALLET.PNL_DETAIL.ITEM.DECIMALS
        pub decimals: i64,
        ///DTO.WALLET.PNL_DETAIL.ITEM.LOGO_URI
        #[serde(
            rename = "logoUri",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub logo_uri: ::std::option::Option<::std::string::String>,
        ///DTO.WALLET.PNL_DETAIL.ITEM.NAME
        pub name: ::std::string::String,
        ///DTO.WALLET.PNL_DETAIL.ITEM.PRICE_IN_USD
        #[serde(rename = "priceInUsd")]
        pub price_in_usd: ::std::string::String,
        ///DTO.WALLET.PNL_DETAIL.ITEM.REALIZED_PROFIT_IN_USD
        #[serde(rename = "realizedProfitInUsd")]
        pub realized_profit_in_usd: ::std::string::String,
        ///DTO.WALLET.PNL_DETAIL.ITEM.REALIZED_PROFIT_RATIO
        #[serde(rename = "realizedProfitRatio")]
        pub realized_profit_ratio: ::std::string::String,
        ///DTO.WALLET.PNL_DETAIL.ITEM.SELL_AMOUNT
        #[serde(rename = "sellAmount")]
        pub sell_amount: ::std::string::String,
        ///DTO.WALLET.PNL_DETAIL.ITEM.SELL_AMOUNT_IN_USD
        #[serde(rename = "sellAmountInUsd")]
        pub sell_amount_in_usd: ::std::string::String,
        ///DTO.WALLET.PNL_DETAIL.ITEM.SELLS
        pub sells: ::std::string::String,
        ///DTO.WALLET.PNL_DETAIL.ITEM.SYMBOL
        pub symbol: ::std::string::String,
        ///DTO.WALLET.PNL_DETAIL.ITEM.TOKEN_ADDRESS
        #[serde(rename = "tokenAddress")]
        pub token_address: ::std::string::String,
        ///DTO.WALLET.PNL_DETAIL.ITEM.TOTAL_PROFIT_IN_USD
        #[serde(rename = "totalProfitInUsd")]
        pub total_profit_in_usd: ::std::string::String,
        ///DTO.WALLET.PNL_DETAIL.ITEM.TOTAL_PROFIT_RATIO
        #[serde(rename = "totalProfitRatio")]
        pub total_profit_ratio: ::std::string::String,
        ///DTO.WALLET.PNL_DETAIL.ITEM.TOTAL_TRADES
        #[serde(rename = "totalTrades")]
        pub total_trades: ::std::string::String,
        ///DTO.WALLET.PNL_DETAIL.ITEM.UNREALIZED_PROFIT_IN_USD
        #[serde(rename = "unrealizedProfitInUsd")]
        pub unrealized_profit_in_usd: ::std::string::String,
        ///DTO.WALLET.PNL_DETAIL.ITEM.UNREALIZED_PROFIT_RATIO
        #[serde(rename = "unrealizedProfitRatio")]
        pub unrealized_profit_ratio: ::std::string::String,
        ///DTO.WALLET.PNL_DETAIL.ITEM.WALLET_ADDRESS
        #[serde(rename = "walletAddress")]
        pub wallet_address: ::std::string::String,
    }
    impl ::std::convert::From<&PnlDetailItemDto> for PnlDetailItemDto {
        fn from(value: &PnlDetailItemDto) -> Self {
            value.clone()
        }
    }
    impl PnlDetailItemDto {
        pub fn builder() -> builder::PnlDetailItemDto {
            Default::default()
        }
    }
    ///`PnlDetailSummaryDto`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "avgProfitPerTradeInUsd",
    ///    "buyAmountInUsd",
    ///    "buys",
    ///    "currentValue",
    ///    "losses",
    ///    "realizedProfitInUsd",
    ///    "realizedProfitRatio",
    ///    "sellAmountInUsd",
    ///    "sells",
    ///    "tokens",
    ///    "totalCostInUsd",
    ///    "totalProfitInUsd",
    ///    "totalTrades",
    ///    "unrealizedProfitInUsd",
    ///    "winRate",
    ///    "wins"
    ///  ],
    ///  "properties": {
    ///    "avgProfitPerTradeInUsd": {
    ///      "description": "DTO.WALLET.PNL_DETAIL.SUMMARY.AVG_PROFIT_PER_TRADE_IN_USD",
    ///      "examples": [
    ///        "132.09"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "buyAmountInUsd": {
    ///      "description": "DTO.WALLET.PNL_DETAIL.SUMMARY.BUY_AMOUNT_IN_USD",
    ///      "examples": [
    ///        "372090700.51"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "buys": {
    ///      "description": "DTO.WALLET.PNL_DETAIL.SUMMARY.BUYS",
    ///      "examples": [
    ///        "6546312"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "currentValue": {
    ///      "description": "DTO.WALLET.PNL_DETAIL.SUMMARY.CURRENT_VALUE",
    ///      "examples": [
    ///        "1397331840.48"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "losses": {
    ///      "description": "DTO.WALLET.PNL_DETAIL.SUMMARY.LOSSES",
    ///      "examples": [
    ///        "1742452"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "realizedProfitInUsd": {
    ///      "description": "DTO.WALLET.PNL_DETAIL.SUMMARY.REALIZED_PROFIT_IN_USD",
    ///      "examples": [
    ///        "-2699411.26"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "realizedProfitRatio": {
    ///      "description": "DTO.WALLET.PNL_DETAIL.SUMMARY.REALIZED_PROFIT_RATIO",
    ///      "examples": [
    ///        "-0.0072547130"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "sellAmountInUsd": {
    ///      "description": "DTO.WALLET.PNL_DETAIL.SUMMARY.SELL_AMOUNT_IN_USD",
    ///      "examples": [
    ///        "214526094.35"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "sells": {
    ///      "description": "DTO.WALLET.PNL_DETAIL.SUMMARY.SELLS",
    ///      "examples": [
    ///        "4012013"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "tokens": {
    ///      "description": "DTO.WALLET.PNL_DETAIL.SUMMARY.TOKENS",
    ///      "examples": [
    ///        "15322"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "totalCostInUsd": {
    ///      "description": "DTO.WALLET.PNL_DETAIL.SUMMARY.TOTAL_COST_IN_USD",
    ///      "examples": [
    ///        "372090700.51"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "totalProfitInUsd": {
    ///      "description": "DTO.WALLET.PNL_DETAIL.SUMMARY.TOTAL_PROFIT_IN_USD",
    ///      "examples": [
    ///        "1394632429.22"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "totalTrades": {
    ///      "description": "DTO.WALLET.PNL_DETAIL.SUMMARY.TOTAL_TRADES",
    ///      "examples": [
    ///        "10558325"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "unrealizedProfitInUsd": {
    ///      "description": "DTO.WALLET.PNL_DETAIL.SUMMARY.UNREALIZED_PROFIT_IN_USD",
    ///      "examples": [
    ///        "1397331840.48"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "winRate": {
    ///      "description": "DTO.WALLET.PNL_DETAIL.SUMMARY.WIN_RATE",
    ///      "examples": [
    ///        "0.5343"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "wins": {
    ///      "description": "DTO.WALLET.PNL_DETAIL.SUMMARY.WINS",
    ///      "examples": [
    ///        "1999472"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct PnlDetailSummaryDto {
        ///DTO.WALLET.PNL_DETAIL.SUMMARY.AVG_PROFIT_PER_TRADE_IN_USD
        #[serde(rename = "avgProfitPerTradeInUsd")]
        pub avg_profit_per_trade_in_usd: ::std::string::String,
        ///DTO.WALLET.PNL_DETAIL.SUMMARY.BUY_AMOUNT_IN_USD
        #[serde(rename = "buyAmountInUsd")]
        pub buy_amount_in_usd: ::std::string::String,
        ///DTO.WALLET.PNL_DETAIL.SUMMARY.BUYS
        pub buys: ::std::string::String,
        ///DTO.WALLET.PNL_DETAIL.SUMMARY.CURRENT_VALUE
        #[serde(rename = "currentValue")]
        pub current_value: ::std::string::String,
        ///DTO.WALLET.PNL_DETAIL.SUMMARY.LOSSES
        pub losses: ::std::string::String,
        ///DTO.WALLET.PNL_DETAIL.SUMMARY.REALIZED_PROFIT_IN_USD
        #[serde(rename = "realizedProfitInUsd")]
        pub realized_profit_in_usd: ::std::string::String,
        ///DTO.WALLET.PNL_DETAIL.SUMMARY.REALIZED_PROFIT_RATIO
        #[serde(rename = "realizedProfitRatio")]
        pub realized_profit_ratio: ::std::string::String,
        ///DTO.WALLET.PNL_DETAIL.SUMMARY.SELL_AMOUNT_IN_USD
        #[serde(rename = "sellAmountInUsd")]
        pub sell_amount_in_usd: ::std::string::String,
        ///DTO.WALLET.PNL_DETAIL.SUMMARY.SELLS
        pub sells: ::std::string::String,
        ///DTO.WALLET.PNL_DETAIL.SUMMARY.TOKENS
        pub tokens: ::std::string::String,
        ///DTO.WALLET.PNL_DETAIL.SUMMARY.TOTAL_COST_IN_USD
        #[serde(rename = "totalCostInUsd")]
        pub total_cost_in_usd: ::std::string::String,
        ///DTO.WALLET.PNL_DETAIL.SUMMARY.TOTAL_PROFIT_IN_USD
        #[serde(rename = "totalProfitInUsd")]
        pub total_profit_in_usd: ::std::string::String,
        ///DTO.WALLET.PNL_DETAIL.SUMMARY.TOTAL_TRADES
        #[serde(rename = "totalTrades")]
        pub total_trades: ::std::string::String,
        ///DTO.WALLET.PNL_DETAIL.SUMMARY.UNREALIZED_PROFIT_IN_USD
        #[serde(rename = "unrealizedProfitInUsd")]
        pub unrealized_profit_in_usd: ::std::string::String,
        ///DTO.WALLET.PNL_DETAIL.SUMMARY.WIN_RATE
        #[serde(rename = "winRate")]
        pub win_rate: ::std::string::String,
        ///DTO.WALLET.PNL_DETAIL.SUMMARY.WINS
        pub wins: ::std::string::String,
    }
    impl ::std::convert::From<&PnlDetailSummaryDto> for PnlDetailSummaryDto {
        fn from(value: &PnlDetailSummaryDto) -> Self {
            value.clone()
        }
    }
    impl PnlDetailSummaryDto {
        pub fn builder() -> builder::PnlDetailSummaryDto {
            Default::default()
        }
    }
    ///`PnlDetailsPage`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "data",
    ///    "summary"
    ///  ],
    ///  "properties": {
    ///    "data": {
    ///      "description": "DTO.PAGE.DATA",
    ///      "type": "array",
    ///      "items": {
    ///        "$ref": "#/components/schemas/PnlDetailItemDTO"
    ///      }
    ///    },
    ///    "endCursor": {
    ///      "description": "DTO.PAGE.END_CURSOR",
    ///      "type": "string"
    ///    },
    ///    "hasNext": {
    ///      "description": "DTO.PAGE.HAS_NEXT",
    ///      "default": false,
    ///      "type": "boolean"
    ///    },
    ///    "hasPrev": {
    ///      "description": "DTO.PAGE.HAS_PREV",
    ///      "default": false,
    ///      "type": "boolean"
    ///    },
    ///    "startCursor": {
    ///      "description": "DTO.PAGE.START_CURSOR",
    ///      "type": "string"
    ///    },
    ///    "summary": {
    ///      "description": "DTO.WALLET.PNL_DETAIL.SUMMARY",
    ///      "allOf": [
    ///        {
    ///          "$ref": "#/components/schemas/PnlDetailSummaryDTO"
    ///        }
    ///      ]
    ///    },
    ///    "total": {
    ///      "description": "DTO.PAGE.TOTAL",
    ///      "default": 0,
    ///      "type": "integer",
    ///      "format": "int64"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct PnlDetailsPage {
        ///DTO.PAGE.DATA
        pub data: ::std::vec::Vec<PnlDetailItemDto>,
        ///DTO.PAGE.END_CURSOR
        #[serde(
            rename = "endCursor",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub end_cursor: ::std::option::Option<::std::string::String>,
        ///DTO.PAGE.HAS_NEXT
        #[serde(rename = "hasNext", default)]
        pub has_next: bool,
        ///DTO.PAGE.HAS_PREV
        #[serde(rename = "hasPrev", default)]
        pub has_prev: bool,
        ///DTO.PAGE.START_CURSOR
        #[serde(
            rename = "startCursor",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub start_cursor: ::std::option::Option<::std::string::String>,
        ///DTO.WALLET.PNL_DETAIL.SUMMARY
        pub summary: PnlDetailSummaryDto,
        ///DTO.PAGE.TOTAL
        #[serde(default)]
        pub total: i64,
    }
    impl ::std::convert::From<&PnlDetailsPage> for PnlDetailsPage {
        fn from(value: &PnlDetailsPage) -> Self {
            value.clone()
        }
    }
    impl PnlDetailsPage {
        pub fn builder() -> builder::PnlDetailsPage {
            Default::default()
        }
    }
    ///`PnlResolution`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "string",
    ///  "enum": [
    ///    "1d",
    ///    "7d",
    ///    "30d",
    ///    "all"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum PnlResolution {
        #[serde(rename = "1d")]
        X1d,
        #[serde(rename = "7d")]
        X7d,
        #[serde(rename = "30d")]
        X30d,
        #[serde(rename = "all")]
        All,
    }
    impl ::std::convert::From<&Self> for PnlResolution {
        fn from(value: &PnlResolution) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for PnlResolution {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::X1d => f.write_str("1d"),
                Self::X7d => f.write_str("7d"),
                Self::X30d => f.write_str("30d"),
                Self::All => f.write_str("all"),
            }
        }
    }
    impl ::std::str::FromStr for PnlResolution {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "1d" => Ok(Self::X1d),
                "7d" => Ok(Self::X7d),
                "30d" => Ok(Self::X30d),
                "all" => Ok(Self::All),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for PnlResolution {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String> for PnlResolution {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for PnlResolution {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    ///`PriceType`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "string",
    ///  "enum": [
    ///    "usd",
    ///    "native"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum PriceType {
        #[serde(rename = "usd")]
        Usd,
        #[serde(rename = "native")]
        Native,
    }
    impl ::std::convert::From<&Self> for PriceType {
        fn from(value: &PriceType) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for PriceType {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::Usd => f.write_str("usd"),
                Self::Native => f.write_str("native"),
            }
        }
    }
    impl ::std::str::FromStr for PriceType {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "usd" => Ok(Self::Usd),
                "native" => Ok(Self::Native),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for PriceType {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String> for PriceType {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for PriceType {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    ///`PumpCreateTokenInput`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "description",
    ///    "dex",
    ///    "image",
    ///    "migrationDex",
    ///    "mintAddress",
    ///    "name",
    ///    "symbol",
    ///    "userAddress"
    ///  ],
    ///  "properties": {
    ///    "description": {
    ///      "description": "DTO.DEX.PUMPFUN.MINT.DESCRIPTION",
    ///      "examples": [
    ///        "A revolutionary new token on Solana"
    ///      ],
    ///      "type": "string",
    ///      "maxLength": 1000
    ///    },
    ///    "dex": {
    ///      "description": "DTO.DEX.IDENTIFIER",
    ///      "examples": [
    ///        "pumpfun"
    ///      ],
    ///      "type": "string",
    ///      "enum": [
    ///        "pumpfun"
    ///      ]
    ///    },
    ///    "image": {
    ///      "description": "DTO.DEX.PUMPFUN.MINT.IMAGE",
    ///      "examples": [
    ///        "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAA..."
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "migrationDex": {
    ///      "description": "DTO.DEX.PUMPFUN.MINT.MIGRATION_DEX",
    ///      "examples": [
    ///        "RAYDIUM"
    ///      ],
    ///      "type": "string",
    ///      "enum": [
    ///        "RAYDIUM",
    ///        "METEORA"
    ///      ]
    ///    },
    ///    "mintAddress": {
    ///      "description": "DTO.DEX.PUMPFUN.MINT.MINT_ADDRESS",
    ///      "examples": [
    ///        "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"
    ///      ],
    ///      "type": "string",
    ///      "maxLength": 44,
    ///      "minLength": 32
    ///    },
    ///    "name": {
    ///      "description": "DTO.DEX.PUMPFUN.MINT.NAME",
    ///      "examples": [
    ///        "My Token"
    ///      ],
    ///      "type": "string",
    ///      "maxLength": 32,
    ///      "minLength": 1
    ///    },
    ///    "priorityFee": {
    ///      "description": "DTO.DEX.BASE.PRIORITY_FEE",
    ///      "examples": [
    ///        "1000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "symbol": {
    ///      "description": "DTO.DEX.PUMPFUN.MINT.SYMBOL",
    ///      "examples": [
    ///        "MTK"
    ///      ],
    ///      "type": "string",
    ///      "maxLength": 10,
    ///      "minLength": 1
    ///    },
    ///    "telegram": {
    ///      "description": "DTO.DEX.PUMPFUN.MINT.TELEGRAM",
    ///      "examples": [
    ///        "https://t.me/mytoken"
    ///      ],
    ///      "type": "string",
    ///      "pattern": "^https://t.me/"
    ///    },
    ///    "twitter": {
    ///      "description": "DTO.DEX.PUMPFUN.MINT.TWITTER",
    ///      "examples": [
    ///        "@mytoken"
    ///      ],
    ///      "type": "string",
    ///      "pattern": "^(@[a-zA-Z0-9_]{1,15}|https://twitter.com/[a-zA-Z0-9_]{1,15})$"
    ///    },
    ///    "userAddress": {
    ///      "description": "DTO.DEX.WALLET",
    ///      "examples": [
    ///        "oQPnhXAbLbMuKHESaGrbXT17CyvWCpLyERSJA9HCYd7"
    ///      ],
    ///      "type": "string",
    ///      "maxLength": 64,
    ///      "minLength": 8
    ///    },
    ///    "website": {
    ///      "description": "DTO.DEX.PUMPFUN.MINT.WEBSITE",
    ///      "examples": [
    ///        "https://mytoken.com"
    ///      ],
    ///      "type": "string",
    ///      "pattern": "^https?://"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct PumpCreateTokenInput {
        ///DTO.DEX.PUMPFUN.MINT.DESCRIPTION
        pub description: PumpCreateTokenInputDescription,
        ///DTO.DEX.IDENTIFIER
        pub dex: PumpCreateTokenInputDex,
        ///DTO.DEX.PUMPFUN.MINT.IMAGE
        pub image: ::std::string::String,
        ///DTO.DEX.PUMPFUN.MINT.MIGRATION_DEX
        #[serde(rename = "migrationDex")]
        pub migration_dex: PumpCreateTokenInputMigrationDex,
        ///DTO.DEX.PUMPFUN.MINT.MINT_ADDRESS
        #[serde(rename = "mintAddress")]
        pub mint_address: PumpCreateTokenInputMintAddress,
        ///DTO.DEX.PUMPFUN.MINT.NAME
        pub name: PumpCreateTokenInputName,
        ///DTO.DEX.BASE.PRIORITY_FEE
        #[serde(
            rename = "priorityFee",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub priority_fee: ::std::option::Option<::std::string::String>,
        ///DTO.DEX.PUMPFUN.MINT.SYMBOL
        pub symbol: PumpCreateTokenInputSymbol,
        ///DTO.DEX.PUMPFUN.MINT.TELEGRAM
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub telegram: ::std::option::Option<PumpCreateTokenInputTelegram>,
        ///DTO.DEX.PUMPFUN.MINT.TWITTER
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub twitter: ::std::option::Option<PumpCreateTokenInputTwitter>,
        ///DTO.DEX.WALLET
        #[serde(rename = "userAddress")]
        pub user_address: PumpCreateTokenInputUserAddress,
        ///DTO.DEX.PUMPFUN.MINT.WEBSITE
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub website: ::std::option::Option<PumpCreateTokenInputWebsite>,
    }
    impl ::std::convert::From<&PumpCreateTokenInput> for PumpCreateTokenInput {
        fn from(value: &PumpCreateTokenInput) -> Self {
            value.clone()
        }
    }
    impl PumpCreateTokenInput {
        pub fn builder() -> builder::PumpCreateTokenInput {
            Default::default()
        }
    }
    ///DTO.DEX.PUMPFUN.MINT.DESCRIPTION
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "DTO.DEX.PUMPFUN.MINT.DESCRIPTION",
    ///  "examples": [
    ///    "A revolutionary new token on Solana"
    ///  ],
    ///  "type": "string",
    ///  "maxLength": 1000
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
    #[serde(transparent)]
    pub struct PumpCreateTokenInputDescription(::std::string::String);
    impl ::std::ops::Deref for PumpCreateTokenInputDescription {
        type Target = ::std::string::String;
        fn deref(&self) -> &::std::string::String {
            &self.0
        }
    }
    impl ::std::convert::From<PumpCreateTokenInputDescription>
    for ::std::string::String {
        fn from(value: PumpCreateTokenInputDescription) -> Self {
            value.0
        }
    }
    impl ::std::convert::From<&PumpCreateTokenInputDescription>
    for PumpCreateTokenInputDescription {
        fn from(value: &PumpCreateTokenInputDescription) -> Self {
            value.clone()
        }
    }
    impl ::std::str::FromStr for PumpCreateTokenInputDescription {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            if value.chars().count() > 1000usize {
                return Err("longer than 1000 characters".into());
            }
            Ok(Self(value.to_string()))
        }
    }
    impl ::std::convert::TryFrom<&str> for PumpCreateTokenInputDescription {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String>
    for PumpCreateTokenInputDescription {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String>
    for PumpCreateTokenInputDescription {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl<'de> ::serde::Deserialize<'de> for PumpCreateTokenInputDescription {
        fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
        where
            D: ::serde::Deserializer<'de>,
        {
            ::std::string::String::deserialize(deserializer)?
                .parse()
                .map_err(|e: self::error::ConversionError| {
                    <D::Error as ::serde::de::Error>::custom(e.to_string())
                })
        }
    }
    ///DTO.DEX.IDENTIFIER
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "DTO.DEX.IDENTIFIER",
    ///  "examples": [
    ///    "pumpfun"
    ///  ],
    ///  "type": "string",
    ///  "enum": [
    ///    "pumpfun"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum PumpCreateTokenInputDex {
        #[serde(rename = "pumpfun")]
        Pumpfun,
    }
    impl ::std::convert::From<&Self> for PumpCreateTokenInputDex {
        fn from(value: &PumpCreateTokenInputDex) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for PumpCreateTokenInputDex {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::Pumpfun => f.write_str("pumpfun"),
            }
        }
    }
    impl ::std::str::FromStr for PumpCreateTokenInputDex {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "pumpfun" => Ok(Self::Pumpfun),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for PumpCreateTokenInputDex {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String> for PumpCreateTokenInputDex {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for PumpCreateTokenInputDex {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    ///DTO.DEX.PUMPFUN.MINT.MIGRATION_DEX
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "DTO.DEX.PUMPFUN.MINT.MIGRATION_DEX",
    ///  "examples": [
    ///    "RAYDIUM"
    ///  ],
    ///  "type": "string",
    ///  "enum": [
    ///    "RAYDIUM",
    ///    "METEORA"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum PumpCreateTokenInputMigrationDex {
        #[serde(rename = "RAYDIUM")]
        Raydium,
        #[serde(rename = "METEORA")]
        Meteora,
    }
    impl ::std::convert::From<&Self> for PumpCreateTokenInputMigrationDex {
        fn from(value: &PumpCreateTokenInputMigrationDex) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for PumpCreateTokenInputMigrationDex {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::Raydium => f.write_str("RAYDIUM"),
                Self::Meteora => f.write_str("METEORA"),
            }
        }
    }
    impl ::std::str::FromStr for PumpCreateTokenInputMigrationDex {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "RAYDIUM" => Ok(Self::Raydium),
                "METEORA" => Ok(Self::Meteora),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for PumpCreateTokenInputMigrationDex {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String>
    for PumpCreateTokenInputMigrationDex {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String>
    for PumpCreateTokenInputMigrationDex {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    ///DTO.DEX.PUMPFUN.MINT.MINT_ADDRESS
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "DTO.DEX.PUMPFUN.MINT.MINT_ADDRESS",
    ///  "examples": [
    ///    "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"
    ///  ],
    ///  "type": "string",
    ///  "maxLength": 44,
    ///  "minLength": 32
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
    #[serde(transparent)]
    pub struct PumpCreateTokenInputMintAddress(::std::string::String);
    impl ::std::ops::Deref for PumpCreateTokenInputMintAddress {
        type Target = ::std::string::String;
        fn deref(&self) -> &::std::string::String {
            &self.0
        }
    }
    impl ::std::convert::From<PumpCreateTokenInputMintAddress>
    for ::std::string::String {
        fn from(value: PumpCreateTokenInputMintAddress) -> Self {
            value.0
        }
    }
    impl ::std::convert::From<&PumpCreateTokenInputMintAddress>
    for PumpCreateTokenInputMintAddress {
        fn from(value: &PumpCreateTokenInputMintAddress) -> Self {
            value.clone()
        }
    }
    impl ::std::str::FromStr for PumpCreateTokenInputMintAddress {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            if value.chars().count() > 44usize {
                return Err("longer than 44 characters".into());
            }
            if value.chars().count() < 32usize {
                return Err("shorter than 32 characters".into());
            }
            Ok(Self(value.to_string()))
        }
    }
    impl ::std::convert::TryFrom<&str> for PumpCreateTokenInputMintAddress {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String>
    for PumpCreateTokenInputMintAddress {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String>
    for PumpCreateTokenInputMintAddress {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl<'de> ::serde::Deserialize<'de> for PumpCreateTokenInputMintAddress {
        fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
        where
            D: ::serde::Deserializer<'de>,
        {
            ::std::string::String::deserialize(deserializer)?
                .parse()
                .map_err(|e: self::error::ConversionError| {
                    <D::Error as ::serde::de::Error>::custom(e.to_string())
                })
        }
    }
    ///DTO.DEX.PUMPFUN.MINT.NAME
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "DTO.DEX.PUMPFUN.MINT.NAME",
    ///  "examples": [
    ///    "My Token"
    ///  ],
    ///  "type": "string",
    ///  "maxLength": 32,
    ///  "minLength": 1
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
    #[serde(transparent)]
    pub struct PumpCreateTokenInputName(::std::string::String);
    impl ::std::ops::Deref for PumpCreateTokenInputName {
        type Target = ::std::string::String;
        fn deref(&self) -> &::std::string::String {
            &self.0
        }
    }
    impl ::std::convert::From<PumpCreateTokenInputName> for ::std::string::String {
        fn from(value: PumpCreateTokenInputName) -> Self {
            value.0
        }
    }
    impl ::std::convert::From<&PumpCreateTokenInputName> for PumpCreateTokenInputName {
        fn from(value: &PumpCreateTokenInputName) -> Self {
            value.clone()
        }
    }
    impl ::std::str::FromStr for PumpCreateTokenInputName {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            if value.chars().count() > 32usize {
                return Err("longer than 32 characters".into());
            }
            if value.chars().count() < 1usize {
                return Err("shorter than 1 characters".into());
            }
            Ok(Self(value.to_string()))
        }
    }
    impl ::std::convert::TryFrom<&str> for PumpCreateTokenInputName {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String> for PumpCreateTokenInputName {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for PumpCreateTokenInputName {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl<'de> ::serde::Deserialize<'de> for PumpCreateTokenInputName {
        fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
        where
            D: ::serde::Deserializer<'de>,
        {
            ::std::string::String::deserialize(deserializer)?
                .parse()
                .map_err(|e: self::error::ConversionError| {
                    <D::Error as ::serde::de::Error>::custom(e.to_string())
                })
        }
    }
    ///DTO.DEX.PUMPFUN.MINT.SYMBOL
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "DTO.DEX.PUMPFUN.MINT.SYMBOL",
    ///  "examples": [
    ///    "MTK"
    ///  ],
    ///  "type": "string",
    ///  "maxLength": 10,
    ///  "minLength": 1
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
    #[serde(transparent)]
    pub struct PumpCreateTokenInputSymbol(::std::string::String);
    impl ::std::ops::Deref for PumpCreateTokenInputSymbol {
        type Target = ::std::string::String;
        fn deref(&self) -> &::std::string::String {
            &self.0
        }
    }
    impl ::std::convert::From<PumpCreateTokenInputSymbol> for ::std::string::String {
        fn from(value: PumpCreateTokenInputSymbol) -> Self {
            value.0
        }
    }
    impl ::std::convert::From<&PumpCreateTokenInputSymbol>
    for PumpCreateTokenInputSymbol {
        fn from(value: &PumpCreateTokenInputSymbol) -> Self {
            value.clone()
        }
    }
    impl ::std::str::FromStr for PumpCreateTokenInputSymbol {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            if value.chars().count() > 10usize {
                return Err("longer than 10 characters".into());
            }
            if value.chars().count() < 1usize {
                return Err("shorter than 1 characters".into());
            }
            Ok(Self(value.to_string()))
        }
    }
    impl ::std::convert::TryFrom<&str> for PumpCreateTokenInputSymbol {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String> for PumpCreateTokenInputSymbol {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for PumpCreateTokenInputSymbol {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl<'de> ::serde::Deserialize<'de> for PumpCreateTokenInputSymbol {
        fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
        where
            D: ::serde::Deserializer<'de>,
        {
            ::std::string::String::deserialize(deserializer)?
                .parse()
                .map_err(|e: self::error::ConversionError| {
                    <D::Error as ::serde::de::Error>::custom(e.to_string())
                })
        }
    }
    ///DTO.DEX.PUMPFUN.MINT.TELEGRAM
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "DTO.DEX.PUMPFUN.MINT.TELEGRAM",
    ///  "examples": [
    ///    "https://t.me/mytoken"
    ///  ],
    ///  "type": "string",
    ///  "pattern": "^https://t.me/"
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
    #[serde(transparent)]
    pub struct PumpCreateTokenInputTelegram(::std::string::String);
    impl ::std::ops::Deref for PumpCreateTokenInputTelegram {
        type Target = ::std::string::String;
        fn deref(&self) -> &::std::string::String {
            &self.0
        }
    }
    impl ::std::convert::From<PumpCreateTokenInputTelegram> for ::std::string::String {
        fn from(value: PumpCreateTokenInputTelegram) -> Self {
            value.0
        }
    }
    impl ::std::convert::From<&PumpCreateTokenInputTelegram>
    for PumpCreateTokenInputTelegram {
        fn from(value: &PumpCreateTokenInputTelegram) -> Self {
            value.clone()
        }
    }
    impl ::std::str::FromStr for PumpCreateTokenInputTelegram {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            static PATTERN: ::std::sync::LazyLock<::regress::Regex> = ::std::sync::LazyLock::new(||
            { ::regress::Regex::new("^https://t.me/").unwrap() });
            if PATTERN.find(value).is_none() {
                return Err("doesn't match pattern \"^https://t.me/\"".into());
            }
            Ok(Self(value.to_string()))
        }
    }
    impl ::std::convert::TryFrom<&str> for PumpCreateTokenInputTelegram {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String>
    for PumpCreateTokenInputTelegram {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String>
    for PumpCreateTokenInputTelegram {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl<'de> ::serde::Deserialize<'de> for PumpCreateTokenInputTelegram {
        fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
        where
            D: ::serde::Deserializer<'de>,
        {
            ::std::string::String::deserialize(deserializer)?
                .parse()
                .map_err(|e: self::error::ConversionError| {
                    <D::Error as ::serde::de::Error>::custom(e.to_string())
                })
        }
    }
    ///DTO.DEX.PUMPFUN.MINT.TWITTER
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "DTO.DEX.PUMPFUN.MINT.TWITTER",
    ///  "examples": [
    ///    "@mytoken"
    ///  ],
    ///  "type": "string",
    ///  "pattern": "^(@[a-zA-Z0-9_]{1,15}|https://twitter.com/[a-zA-Z0-9_]{1,15})$"
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
    #[serde(transparent)]
    pub struct PumpCreateTokenInputTwitter(::std::string::String);
    impl ::std::ops::Deref for PumpCreateTokenInputTwitter {
        type Target = ::std::string::String;
        fn deref(&self) -> &::std::string::String {
            &self.0
        }
    }
    impl ::std::convert::From<PumpCreateTokenInputTwitter> for ::std::string::String {
        fn from(value: PumpCreateTokenInputTwitter) -> Self {
            value.0
        }
    }
    impl ::std::convert::From<&PumpCreateTokenInputTwitter>
    for PumpCreateTokenInputTwitter {
        fn from(value: &PumpCreateTokenInputTwitter) -> Self {
            value.clone()
        }
    }
    impl ::std::str::FromStr for PumpCreateTokenInputTwitter {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            static PATTERN: ::std::sync::LazyLock<::regress::Regex> = ::std::sync::LazyLock::new(||
            {
                ::regress::Regex::new(
                        "^(@[a-zA-Z0-9_]{1,15}|https://twitter.com/[a-zA-Z0-9_]{1,15})$",
                    )
                    .unwrap()
            });
            if PATTERN.find(value).is_none() {
                return Err(
                    "doesn't match pattern \"^(@[a-zA-Z0-9_]{1,15}|https://twitter.com/[a-zA-Z0-9_]{1,15})$\""
                        .into(),
                );
            }
            Ok(Self(value.to_string()))
        }
    }
    impl ::std::convert::TryFrom<&str> for PumpCreateTokenInputTwitter {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String>
    for PumpCreateTokenInputTwitter {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for PumpCreateTokenInputTwitter {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl<'de> ::serde::Deserialize<'de> for PumpCreateTokenInputTwitter {
        fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
        where
            D: ::serde::Deserializer<'de>,
        {
            ::std::string::String::deserialize(deserializer)?
                .parse()
                .map_err(|e: self::error::ConversionError| {
                    <D::Error as ::serde::de::Error>::custom(e.to_string())
                })
        }
    }
    ///DTO.DEX.WALLET
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "DTO.DEX.WALLET",
    ///  "examples": [
    ///    "oQPnhXAbLbMuKHESaGrbXT17CyvWCpLyERSJA9HCYd7"
    ///  ],
    ///  "type": "string",
    ///  "maxLength": 64,
    ///  "minLength": 8
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
    #[serde(transparent)]
    pub struct PumpCreateTokenInputUserAddress(::std::string::String);
    impl ::std::ops::Deref for PumpCreateTokenInputUserAddress {
        type Target = ::std::string::String;
        fn deref(&self) -> &::std::string::String {
            &self.0
        }
    }
    impl ::std::convert::From<PumpCreateTokenInputUserAddress>
    for ::std::string::String {
        fn from(value: PumpCreateTokenInputUserAddress) -> Self {
            value.0
        }
    }
    impl ::std::convert::From<&PumpCreateTokenInputUserAddress>
    for PumpCreateTokenInputUserAddress {
        fn from(value: &PumpCreateTokenInputUserAddress) -> Self {
            value.clone()
        }
    }
    impl ::std::str::FromStr for PumpCreateTokenInputUserAddress {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            if value.chars().count() > 64usize {
                return Err("longer than 64 characters".into());
            }
            if value.chars().count() < 8usize {
                return Err("shorter than 8 characters".into());
            }
            Ok(Self(value.to_string()))
        }
    }
    impl ::std::convert::TryFrom<&str> for PumpCreateTokenInputUserAddress {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String>
    for PumpCreateTokenInputUserAddress {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String>
    for PumpCreateTokenInputUserAddress {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl<'de> ::serde::Deserialize<'de> for PumpCreateTokenInputUserAddress {
        fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
        where
            D: ::serde::Deserializer<'de>,
        {
            ::std::string::String::deserialize(deserializer)?
                .parse()
                .map_err(|e: self::error::ConversionError| {
                    <D::Error as ::serde::de::Error>::custom(e.to_string())
                })
        }
    }
    ///DTO.DEX.PUMPFUN.MINT.WEBSITE
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "DTO.DEX.PUMPFUN.MINT.WEBSITE",
    ///  "examples": [
    ///    "https://mytoken.com"
    ///  ],
    ///  "type": "string",
    ///  "pattern": "^https?://"
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
    #[serde(transparent)]
    pub struct PumpCreateTokenInputWebsite(::std::string::String);
    impl ::std::ops::Deref for PumpCreateTokenInputWebsite {
        type Target = ::std::string::String;
        fn deref(&self) -> &::std::string::String {
            &self.0
        }
    }
    impl ::std::convert::From<PumpCreateTokenInputWebsite> for ::std::string::String {
        fn from(value: PumpCreateTokenInputWebsite) -> Self {
            value.0
        }
    }
    impl ::std::convert::From<&PumpCreateTokenInputWebsite>
    for PumpCreateTokenInputWebsite {
        fn from(value: &PumpCreateTokenInputWebsite) -> Self {
            value.clone()
        }
    }
    impl ::std::str::FromStr for PumpCreateTokenInputWebsite {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            static PATTERN: ::std::sync::LazyLock<::regress::Regex> = ::std::sync::LazyLock::new(||
            { ::regress::Regex::new("^https?://").unwrap() });
            if PATTERN.find(value).is_none() {
                return Err("doesn't match pattern \"^https?://\"".into());
            }
            Ok(Self(value.to_string()))
        }
    }
    impl ::std::convert::TryFrom<&str> for PumpCreateTokenInputWebsite {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String>
    for PumpCreateTokenInputWebsite {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for PumpCreateTokenInputWebsite {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl<'de> ::serde::Deserialize<'de> for PumpCreateTokenInputWebsite {
        fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
        where
            D: ::serde::Deserializer<'de>,
        {
            ::std::string::String::deserialize(deserializer)?
                .parse()
                .map_err(|e: self::error::ConversionError| {
                    <D::Error as ::serde::de::Error>::custom(e.to_string())
                })
        }
    }
    ///`PumpCreateTokenReply`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "serializedTx"
    ///  ],
    ///  "properties": {
    ///    "extra": {
    ///      "description": "DTO.DEX.PUMPFUN.MINT.EXTRA",
    ///      "examples": [
    ///        {
    ///          "token": {
    ///            "address": "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA",
    ///            "decimals": 9
    ///          },
    ///          "tokenId": "pump_123456"
    ///        }
    ///      ],
    ///      "type": "object"
    ///    },
    ///    "serializedTx": {
    ///      "description": "DTO.DEX.PUMPFUN.MINT.SERIALIZED_TX",
    ///      "examples": [
    ///        "AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAEDRgYGpQEDAQIABQcICQoLDA0ODwAAAAAAAAAAAAAQERITFBUWFxgZGhscHR4fAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA="
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct PumpCreateTokenReply {
        ///DTO.DEX.PUMPFUN.MINT.EXTRA
        #[serde(default, skip_serializing_if = "::serde_json::Map::is_empty")]
        pub extra: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
        ///DTO.DEX.PUMPFUN.MINT.SERIALIZED_TX
        #[serde(rename = "serializedTx")]
        pub serialized_tx: ::std::string::String,
    }
    impl ::std::convert::From<&PumpCreateTokenReply> for PumpCreateTokenReply {
        fn from(value: &PumpCreateTokenReply) -> Self {
            value.clone()
        }
    }
    impl PumpCreateTokenReply {
        pub fn builder() -> builder::PumpCreateTokenReply {
            Default::default()
        }
    }
    ///`QuoteDex`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "examples": [
    ///    "raydium"
    ///  ],
    ///  "type": "string",
    ///  "enum": [
    ///    "raydium",
    ///    "pumpfun"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum QuoteDex {
        #[serde(rename = "raydium")]
        Raydium,
        #[serde(rename = "pumpfun")]
        Pumpfun,
    }
    impl ::std::convert::From<&Self> for QuoteDex {
        fn from(value: &QuoteDex) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for QuoteDex {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::Raydium => f.write_str("raydium"),
                Self::Pumpfun => f.write_str("pumpfun"),
            }
        }
    }
    impl ::std::str::FromStr for QuoteDex {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "raydium" => Ok(Self::Raydium),
                "pumpfun" => Ok(Self::Pumpfun),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for QuoteDex {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String> for QuoteDex {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for QuoteDex {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    ///`RedPacketClaimDto`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "amount",
    ///    "chain",
    ///    "claimedAt",
    ///    "claimer",
    ///    "creator",
    ///    "mint",
    ///    "packetId",
    ///    "txHash"
    ///  ],
    ///  "properties": {
    ///    "amount": {
    ///      "description": "DTO.RED_PACKET.AMOUNT",
    ///      "examples": [
    ///        "1000000000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "chain": {
    ///      "description": "DTO.RED_PACKET.CHAIN",
    ///      "examples": [
    ///        "sol"
    ///      ],
    ///      "allOf": [
    ///        {
    ///          "$ref": "#/components/schemas/Chain"
    ///        }
    ///      ]
    ///    },
    ///    "claimedAt": {
    ///      "description": "DTO.RED_PACKET.CLAIMED_AT",
    ///      "examples": [
    ///        1717334400000
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "claimer": {
    ///      "description": "DTO.RED_PACKET.CLAIMER",
    ///      "examples": [
    ///        "Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "creator": {
    ///      "description": "DTO.RED_PACKET.CREATOR",
    ///      "examples": [
    ///        "Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "mint": {
    ///      "description": "DTO.RED_PACKET.MINT",
    ///      "examples": [
    ///        "Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "packetId": {
    ///      "description": "DTO.RED_PACKET.PACKET_ID",
    ///      "examples": [
    ///        "Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "txHash": {
    ///      "description": "DTO.RED_PACKET.TX_HASH",
    ///      "examples": [
    ///        "123456"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct RedPacketClaimDto {
        ///DTO.RED_PACKET.AMOUNT
        pub amount: ::std::string::String,
        ///DTO.RED_PACKET.CHAIN
        pub chain: Chain,
        ///DTO.RED_PACKET.CLAIMED_AT
        #[serde(rename = "claimedAt")]
        pub claimed_at: i64,
        ///DTO.RED_PACKET.CLAIMER
        pub claimer: ::std::string::String,
        ///DTO.RED_PACKET.CREATOR
        pub creator: ::std::string::String,
        ///DTO.RED_PACKET.MINT
        pub mint: ::std::string::String,
        ///DTO.RED_PACKET.PACKET_ID
        #[serde(rename = "packetId")]
        pub packet_id: ::std::string::String,
        ///DTO.RED_PACKET.TX_HASH
        #[serde(rename = "txHash")]
        pub tx_hash: ::std::string::String,
    }
    impl ::std::convert::From<&RedPacketClaimDto> for RedPacketClaimDto {
        fn from(value: &RedPacketClaimDto) -> Self {
            value.clone()
        }
    }
    impl RedPacketClaimDto {
        pub fn builder() -> builder::RedPacketClaimDto {
            Default::default()
        }
    }
    ///`RedPacketClaimsPage`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "endCursor",
    ///    "hasNextPage",
    ///    "records",
    ///    "startCursor",
    ///    "total"
    ///  ],
    ///  "properties": {
    ///    "endCursor": {
    ///      "description": "DTO.PAGE.END_CURSOR",
    ///      "examples": [
    ///        "cursor_456"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "hasNextPage": {
    ///      "description": "DTO.PAGE.HAS_NEXT",
    ///      "examples": [
    ///        true
    ///      ],
    ///      "type": "boolean"
    ///    },
    ///    "records": {
    ///      "description": "Array of claim records",
    ///      "type": "array",
    ///      "items": {
    ///        "$ref": "#/components/schemas/RedPacketClaimDTO"
    ///      }
    ///    },
    ///    "startCursor": {
    ///      "description": "DTO.PAGE.START_CURSOR",
    ///      "examples": [
    ///        "cursor_123"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "total": {
    ///      "description": "DTO.PAGE.TOTAL",
    ///      "examples": [
    ///        100
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct RedPacketClaimsPage {
        ///DTO.PAGE.END_CURSOR
        #[serde(rename = "endCursor")]
        pub end_cursor: ::std::string::String,
        ///DTO.PAGE.HAS_NEXT
        #[serde(rename = "hasNextPage")]
        pub has_next_page: bool,
        ///Array of claim records
        pub records: ::std::vec::Vec<RedPacketClaimDto>,
        ///DTO.PAGE.START_CURSOR
        #[serde(rename = "startCursor")]
        pub start_cursor: ::std::string::String,
        ///DTO.PAGE.TOTAL
        pub total: i64,
    }
    impl ::std::convert::From<&RedPacketClaimsPage> for RedPacketClaimsPage {
        fn from(value: &RedPacketClaimsPage) -> Self {
            value.clone()
        }
    }
    impl RedPacketClaimsPage {
        pub fn builder() -> builder::RedPacketClaimsPage {
            Default::default()
        }
    }
    ///`RedPacketDto`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "chain",
    ///    "claimAuthority",
    ///    "claimedAmount",
    ///    "claimedCount",
    ///    "createdAt",
    ///    "creator",
    ///    "expiration",
    ///    "expired",
    ///    "expiredAt",
    ///    "id",
    ///    "maxClaims",
    ///    "memo",
    ///    "mint",
    ///    "refundedAmount",
    ///    "shareId",
    ///    "totalAmount",
    ///    "txHash"
    ///  ],
    ///  "properties": {
    ///    "chain": {
    ///      "description": "GLOBAL.CHAIN.DESCRIPTION",
    ///      "examples": [
    ///        "sol"
    ///      ],
    ///      "allOf": [
    ///        {
    ///          "$ref": "#/components/schemas/Chain"
    ///        }
    ///      ]
    ///    },
    ///    "claimAuthority": {
    ///      "description": "DTO.RED_PACKET.CLAIM_AUTHORITY",
    ///      "examples": [
    ///        "Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "claimedAmount": {
    ///      "description": "DTO.RED_PACKET.CLAIMED_AMOUNT",
    ///      "examples": [
    ///        "100000000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "claimedCount": {
    ///      "description": "DTO.RED_PACKET.CLAIMED_COUNT",
    ///      "examples": [
    ///        100
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "createdAt": {
    ///      "description": "DTO.RED_PACKET.CREATED_AT",
    ///      "examples": [
    ///        1717334400000
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "creator": {
    ///      "description": "DTO.RED_PACKET.CREATOR",
    ///      "examples": [
    ///        "Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "expiration": {
    ///      "description": "DTO.RED_PACKET.EXPIRATION",
    ///      "examples": [
    ///        24
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "expired": {
    ///      "description": "DTO.RED_PACKET.WITHDRAWED",
    ///      "examples": [
    ///        true
    ///      ],
    ///      "type": "boolean"
    ///    },
    ///    "expiredAt": {
    ///      "description": "DTO.RED_PACKET.EXPIRES_AT",
    ///      "examples": [
    ///        1717334400000
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "id": {
    ///      "description": "DTO.RED_PACKET.ID",
    ///      "examples": [
    ///        "Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "maxClaims": {
    ///      "description": "DTO.RED_PACKET.MAX_CLAIMS",
    ///      "examples": [
    ///        100
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "memo": {
    ///      "description": "DTO.RED_PACKET.MEMO",
    ///      "examples": [
    ///        "Happy Red Packet"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "mint": {
    ///      "description": "DTO.RED_PACKET.MINT",
    ///      "examples": [
    ///        "Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "refundedAmount": {
    ///      "description": "DTO.RED_PACKET.REFUND_AMOUNT",
    ///      "examples": [
    ///        "123456"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "shareId": {
    ///      "description": "DTO.RED_PACKET.SHARE_ID",
    ///      "examples": [
    ///        "123456"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "totalAmount": {
    ///      "description": "DTO.RED_PACKET.TOTAL_AMOUNT",
    ///      "examples": [
    ///        "1000000000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "txHash": {
    ///      "description": "DTO.RED_PACKET.TX_HASH",
    ///      "examples": [
    ///        "123456"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct RedPacketDto {
        ///GLOBAL.CHAIN.DESCRIPTION
        pub chain: Chain,
        ///DTO.RED_PACKET.CLAIM_AUTHORITY
        #[serde(rename = "claimAuthority")]
        pub claim_authority: ::std::string::String,
        ///DTO.RED_PACKET.CLAIMED_AMOUNT
        #[serde(rename = "claimedAmount")]
        pub claimed_amount: ::std::string::String,
        ///DTO.RED_PACKET.CLAIMED_COUNT
        #[serde(rename = "claimedCount")]
        pub claimed_count: i64,
        ///DTO.RED_PACKET.CREATED_AT
        #[serde(rename = "createdAt")]
        pub created_at: i64,
        ///DTO.RED_PACKET.CREATOR
        pub creator: ::std::string::String,
        ///DTO.RED_PACKET.EXPIRATION
        pub expiration: i64,
        ///DTO.RED_PACKET.WITHDRAWED
        pub expired: bool,
        ///DTO.RED_PACKET.EXPIRES_AT
        #[serde(rename = "expiredAt")]
        pub expired_at: i64,
        ///DTO.RED_PACKET.ID
        pub id: ::std::string::String,
        ///DTO.RED_PACKET.MAX_CLAIMS
        #[serde(rename = "maxClaims")]
        pub max_claims: i64,
        ///DTO.RED_PACKET.MEMO
        pub memo: ::std::string::String,
        ///DTO.RED_PACKET.MINT
        pub mint: ::std::string::String,
        ///DTO.RED_PACKET.REFUND_AMOUNT
        #[serde(rename = "refundedAmount")]
        pub refunded_amount: ::std::string::String,
        ///DTO.RED_PACKET.SHARE_ID
        #[serde(rename = "shareId")]
        pub share_id: ::std::string::String,
        ///DTO.RED_PACKET.TOTAL_AMOUNT
        #[serde(rename = "totalAmount")]
        pub total_amount: ::std::string::String,
        ///DTO.RED_PACKET.TX_HASH
        #[serde(rename = "txHash")]
        pub tx_hash: ::std::string::String,
    }
    impl ::std::convert::From<&RedPacketDto> for RedPacketDto {
        fn from(value: &RedPacketDto) -> Self {
            value.clone()
        }
    }
    impl RedPacketDto {
        pub fn builder() -> builder::RedPacketDto {
            Default::default()
        }
    }
    ///`RedPacketReply`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "txSerialize"
    ///  ],
    ///  "properties": {
    ///    "txSerialize": {
    ///      "description": "DTO.RED_PACKET.SERIALIZED_TX",
    ///      "examples": [
    ///        "AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAEDRgYGpQEDAQIABQcICQoLDA0ODwAAAAAAAAAAAAAQERITFBUWFxgZGhscHR4fAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA="
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct RedPacketReply {
        ///DTO.RED_PACKET.SERIALIZED_TX
        #[serde(rename = "txSerialize")]
        pub tx_serialize: ::std::string::String,
    }
    impl ::std::convert::From<&RedPacketReply> for RedPacketReply {
        fn from(value: &RedPacketReply) -> Self {
            value.clone()
        }
    }
    impl RedPacketReply {
        pub fn builder() -> builder::RedPacketReply {
            Default::default()
        }
    }
    ///`RedPacketSendTxInput`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "signedTx"
    ///  ],
    ///  "properties": {
    ///    "signedTx": {
    ///      "description": "DTO.RED_PACKET.SIGNED_TX",
    ///      "examples": [
    ///        "AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAEDRgYGpQEDAQIABQcICQoLDA0ODwAAAAAAAAAAAAAQERITFBUWFxgZGhscHR4fAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA="
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct RedPacketSendTxInput {
        ///DTO.RED_PACKET.SIGNED_TX
        #[serde(rename = "signedTx")]
        pub signed_tx: ::std::string::String,
    }
    impl ::std::convert::From<&RedPacketSendTxInput> for RedPacketSendTxInput {
        fn from(value: &RedPacketSendTxInput) -> Self {
            value.clone()
        }
    }
    impl RedPacketSendTxInput {
        pub fn builder() -> builder::RedPacketSendTxInput {
            Default::default()
        }
    }
    ///`RedPacketSendTxResponse`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "signature"
    ///  ],
    ///  "properties": {
    ///    "signature": {
    ///      "description": "DTO.RED_PACKET.SIGNATURE",
    ///      "examples": [
    ///        "AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAEDRgYGpQEDAQIABQcICQoLDA0ODwAAAAAAAAAAAAAQERITFBUWFxgZGhscHR4fAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA="
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct RedPacketSendTxResponse {
        ///DTO.RED_PACKET.SIGNATURE
        pub signature: ::std::string::String,
    }
    impl ::std::convert::From<&RedPacketSendTxResponse> for RedPacketSendTxResponse {
        fn from(value: &RedPacketSendTxResponse) -> Self {
            value.clone()
        }
    }
    impl RedPacketSendTxResponse {
        pub fn builder() -> builder::RedPacketSendTxResponse {
            Default::default()
        }
    }
    ///`RedPacketsPage`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "endCursor",
    ///    "hasNextPage",
    ///    "records",
    ///    "startCursor",
    ///    "total"
    ///  ],
    ///  "properties": {
    ///    "endCursor": {
    ///      "description": "DTO.PAGE.END_CURSOR",
    ///      "examples": [
    ///        "cursor_456"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "hasNextPage": {
    ///      "description": "DTO.PAGE.HAS_NEXT",
    ///      "examples": [
    ///        true
    ///      ],
    ///      "type": "boolean"
    ///    },
    ///    "records": {
    ///      "description": "Array of red packets",
    ///      "type": "array",
    ///      "items": {
    ///        "$ref": "#/components/schemas/RedPacketDTO"
    ///      }
    ///    },
    ///    "startCursor": {
    ///      "description": "DTO.PAGE.START_CURSOR",
    ///      "examples": [
    ///        "cursor_123"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "total": {
    ///      "description": "DTO.PAGE.TOTAL",
    ///      "examples": [
    ///        100
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct RedPacketsPage {
        ///DTO.PAGE.END_CURSOR
        #[serde(rename = "endCursor")]
        pub end_cursor: ::std::string::String,
        ///DTO.PAGE.HAS_NEXT
        #[serde(rename = "hasNextPage")]
        pub has_next_page: bool,
        ///Array of red packets
        pub records: ::std::vec::Vec<RedPacketDto>,
        ///DTO.PAGE.START_CURSOR
        #[serde(rename = "startCursor")]
        pub start_cursor: ::std::string::String,
        ///DTO.PAGE.TOTAL
        pub total: i64,
    }
    impl ::std::convert::From<&RedPacketsPage> for RedPacketsPage {
        fn from(value: &RedPacketsPage) -> Self {
            value.clone()
        }
    }
    impl RedPacketsPage {
        pub fn builder() -> builder::RedPacketsPage {
            Default::default()
        }
    }
    ///`RegisterAddressRequest`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "address"
    ///  ],
    ///  "properties": {
    ///    "address": {
    ///      "description": "DTO.KYT.REGISTER_ADDRESS_REQUEST.ADDRESS",
    ///      "examples": [
    ///        "0x0038AC785dfB6C82b2c9A7B3B6854e08a10cb9f1"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct RegisterAddressRequest {
        ///DTO.KYT.REGISTER_ADDRESS_REQUEST.ADDRESS
        pub address: ::std::string::String,
    }
    impl ::std::convert::From<&RegisterAddressRequest> for RegisterAddressRequest {
        fn from(value: &RegisterAddressRequest) -> Self {
            value.clone()
        }
    }
    impl RegisterAddressRequest {
        pub fn builder() -> builder::RegisterAddressRequest {
            Default::default()
        }
    }
    ///`RegisterAddressResponseDto`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "address"
    ///  ],
    ///  "properties": {
    ///    "address": {
    ///      "description": "DTO.KYT.REGISTER_ADDRESS_RESPONSE.ADDRESS",
    ///      "examples": [
    ///        "0x0038AC785dfB6C82b2c9A7B3B6854e08a10cb9f1"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct RegisterAddressResponseDto {
        ///DTO.KYT.REGISTER_ADDRESS_RESPONSE.ADDRESS
        pub address: ::std::string::String,
    }
    impl ::std::convert::From<&RegisterAddressResponseDto>
    for RegisterAddressResponseDto {
        fn from(value: &RegisterAddressResponseDto) -> Self {
            value.clone()
        }
    }
    impl RegisterAddressResponseDto {
        pub fn builder() -> builder::RegisterAddressResponseDto {
            Default::default()
        }
    }
    ///`Resolution`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "string",
    ///  "enum": [
    ///    "1s",
    ///    "15s",
    ///    "30s",
    ///    "1m",
    ///    "3m",
    ///    "5m",
    ///    "15m",
    ///    "30m",
    ///    "1h",
    ///    "2h",
    ///    "4h",
    ///    "6h",
    ///    "8h",
    ///    "12h",
    ///    "1d",
    ///    "3d",
    ///    "1w",
    ///    "1Mo"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum Resolution {
        #[serde(rename = "1s")]
        X1s,
        #[serde(rename = "15s")]
        X15s,
        #[serde(rename = "30s")]
        X30s,
        #[serde(rename = "1m")]
        X1m,
        #[serde(rename = "3m")]
        X3m,
        #[serde(rename = "5m")]
        X5m,
        #[serde(rename = "15m")]
        X15m,
        #[serde(rename = "30m")]
        X30m,
        #[serde(rename = "1h")]
        X1h,
        #[serde(rename = "2h")]
        X2h,
        #[serde(rename = "4h")]
        X4h,
        #[serde(rename = "6h")]
        X6h,
        #[serde(rename = "8h")]
        X8h,
        #[serde(rename = "12h")]
        X12h,
        #[serde(rename = "1d")]
        X1d,
        #[serde(rename = "3d")]
        X3d,
        #[serde(rename = "1w")]
        X1w,
        #[serde(rename = "1M")]
        X1mo,
    }
    impl ::std::convert::From<&Self> for Resolution {
        fn from(value: &Resolution) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for Resolution {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::X1s => f.write_str("1s"),
                Self::X15s => f.write_str("15s"),
                Self::X30s => f.write_str("30s"),
                Self::X1m => f.write_str("1m"),
                Self::X3m => f.write_str("3m"),
                Self::X5m => f.write_str("5m"),
                Self::X15m => f.write_str("15m"),
                Self::X30m => f.write_str("30m"),
                Self::X1h => f.write_str("1h"),
                Self::X2h => f.write_str("2h"),
                Self::X4h => f.write_str("4h"),
                Self::X6h => f.write_str("6h"),
                Self::X8h => f.write_str("8h"),
                Self::X12h => f.write_str("12h"),
                Self::X1d => f.write_str("1d"),
                Self::X3d => f.write_str("3d"),
                Self::X1w => f.write_str("1w"),
                Self::X1mo => f.write_str("1M"),
            }
        }
    }
    impl ::std::str::FromStr for Resolution {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "1s" => Ok(Self::X1s),
                "15s" => Ok(Self::X15s),
                "30s" => Ok(Self::X30s),
                "1m" => Ok(Self::X1m),
                "3m" => Ok(Self::X3m),
                "5m" => Ok(Self::X5m),
                "15m" => Ok(Self::X15m),
                "30m" => Ok(Self::X30m),
                "1h" => Ok(Self::X1h),
                "2h" => Ok(Self::X2h),
                "4h" => Ok(Self::X4h),
                "6h" => Ok(Self::X6h),
                "8h" => Ok(Self::X8h),
                "12h" => Ok(Self::X12h),
                "1d" => Ok(Self::X1d),
                "3d" => Ok(Self::X3d),
                "1w" => Ok(Self::X1w),
                "1M" => Ok(Self::X1mo),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for Resolution {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String> for Resolution {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for Resolution {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    ///`SearchDirection`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "default": "next",
    ///  "type": "string",
    ///  "enum": [
    ///    "next",
    ///    "prev"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum SearchDirection {
        #[serde(rename = "next")]
        Next,
        #[serde(rename = "prev")]
        Prev,
    }
    impl ::std::convert::From<&Self> for SearchDirection {
        fn from(value: &SearchDirection) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for SearchDirection {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::Next => f.write_str("next"),
                Self::Prev => f.write_str("prev"),
            }
        }
    }
    impl ::std::str::FromStr for SearchDirection {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "next" => Ok(Self::Next),
                "prev" => Ok(Self::Prev),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for SearchDirection {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String> for SearchDirection {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for SearchDirection {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::default::Default for SearchDirection {
        fn default() -> Self {
            SearchDirection::Next
        }
    }
    ///`SearchQ`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "examples": [
    ///    "USDC"
    ///  ],
    ///  "type": "string",
    ///  "minLength": 1
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
    #[serde(transparent)]
    pub struct SearchQ(::std::string::String);
    impl ::std::ops::Deref for SearchQ {
        type Target = ::std::string::String;
        fn deref(&self) -> &::std::string::String {
            &self.0
        }
    }
    impl ::std::convert::From<SearchQ> for ::std::string::String {
        fn from(value: SearchQ) -> Self {
            value.0
        }
    }
    impl ::std::convert::From<&SearchQ> for SearchQ {
        fn from(value: &SearchQ) -> Self {
            value.clone()
        }
    }
    impl ::std::str::FromStr for SearchQ {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            if value.chars().count() < 1usize {
                return Err("shorter than 1 characters".into());
            }
            Ok(Self(value.to_string()))
        }
    }
    impl ::std::convert::TryFrom<&str> for SearchQ {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String> for SearchQ {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for SearchQ {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl<'de> ::serde::Deserialize<'de> for SearchQ {
        fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
        where
            D: ::serde::Deserializer<'de>,
        {
            ::std::string::String::deserialize(deserializer)?
                .parse()
                .map_err(|e: self::error::ConversionError| {
                    <D::Error as ::serde::de::Error>::custom(e.to_string())
                })
        }
    }
    ///`SearchSort`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "default": "desc",
    ///  "type": "string",
    ///  "enum": [
    ///    "asc",
    ///    "desc"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum SearchSort {
        #[serde(rename = "asc")]
        Asc,
        #[serde(rename = "desc")]
        Desc,
    }
    impl ::std::convert::From<&Self> for SearchSort {
        fn from(value: &SearchSort) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for SearchSort {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::Asc => f.write_str("asc"),
                Self::Desc => f.write_str("desc"),
            }
        }
    }
    impl ::std::str::FromStr for SearchSort {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "asc" => Ok(Self::Asc),
                "desc" => Ok(Self::Desc),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for SearchSort {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String> for SearchSort {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for SearchSort {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::default::Default for SearchSort {
        fn default() -> Self {
            SearchSort::Desc
        }
    }
    ///`SearchSortBy`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "examples": [
    ///    "priceInUsd"
    ///  ],
    ///  "type": "string",
    ///  "enum": [
    ///    "marketCapInUsd",
    ///    "liquidityInUsd",
    ///    "priceInUsd",
    ///    "holderCount",
    ///    "h24VolumeInUsd",
    ///    "h24Transactions",
    ///    "tokenCreatedAt"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum SearchSortBy {
        #[serde(rename = "marketCapInUsd")]
        MarketCapInUsd,
        #[serde(rename = "liquidityInUsd")]
        LiquidityInUsd,
        #[serde(rename = "priceInUsd")]
        PriceInUsd,
        #[serde(rename = "holderCount")]
        HolderCount,
        #[serde(rename = "h24VolumeInUsd")]
        H24VolumeInUsd,
        #[serde(rename = "h24Transactions")]
        H24Transactions,
        #[serde(rename = "tokenCreatedAt")]
        TokenCreatedAt,
    }
    impl ::std::convert::From<&Self> for SearchSortBy {
        fn from(value: &SearchSortBy) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for SearchSortBy {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::MarketCapInUsd => f.write_str("marketCapInUsd"),
                Self::LiquidityInUsd => f.write_str("liquidityInUsd"),
                Self::PriceInUsd => f.write_str("priceInUsd"),
                Self::HolderCount => f.write_str("holderCount"),
                Self::H24VolumeInUsd => f.write_str("h24VolumeInUsd"),
                Self::H24Transactions => f.write_str("h24Transactions"),
                Self::TokenCreatedAt => f.write_str("tokenCreatedAt"),
            }
        }
    }
    impl ::std::str::FromStr for SearchSortBy {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "marketCapInUsd" => Ok(Self::MarketCapInUsd),
                "liquidityInUsd" => Ok(Self::LiquidityInUsd),
                "priceInUsd" => Ok(Self::PriceInUsd),
                "holderCount" => Ok(Self::HolderCount),
                "h24VolumeInUsd" => Ok(Self::H24VolumeInUsd),
                "h24Transactions" => Ok(Self::H24Transactions),
                "tokenCreatedAt" => Ok(Self::TokenCreatedAt),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for SearchSortBy {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String> for SearchSortBy {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for SearchSortBy {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    ///`SendTxInput`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "signedTx"
    ///  ],
    ///  "properties": {
    ///    "options": {
    ///      "description": "DTO.TRANSACTION.SEND.OPTIONS",
    ///      "examples": [
    ///        {
    ///          "isAntiMev": true
    ///        }
    ///      ],
    ///      "type": "object"
    ///    },
    ///    "signedTx": {
    ///      "description": "DTO.TRANSACTION.SEND.SIGNED_TX",
    ///      "examples": [
    ///        "AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAEDRgYGpQEDAQIABQcICQoLDA0ODwAAAAAAAAAAAAAQERITFBUWFxgZGhscHR4fAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA="
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "submitType": {
    ///      "description": "DTO.TRANSACTION.SEND.SUBMIT_TYPE",
    ///      "examples": [
    ///        "default"
    ///      ],
    ///      "type": "string",
    ///      "enum": [
    ///        "default",
    ///        "priority"
    ///      ]
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct SendTxInput {
        ///DTO.TRANSACTION.SEND.OPTIONS
        #[serde(default, skip_serializing_if = "::serde_json::Map::is_empty")]
        pub options: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
        ///DTO.TRANSACTION.SEND.SIGNED_TX
        #[serde(rename = "signedTx")]
        pub signed_tx: ::std::string::String,
        ///DTO.TRANSACTION.SEND.SUBMIT_TYPE
        #[serde(
            rename = "submitType",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub submit_type: ::std::option::Option<SendTxInputSubmitType>,
    }
    impl ::std::convert::From<&SendTxInput> for SendTxInput {
        fn from(value: &SendTxInput) -> Self {
            value.clone()
        }
    }
    impl SendTxInput {
        pub fn builder() -> builder::SendTxInput {
            Default::default()
        }
    }
    ///DTO.TRANSACTION.SEND.SUBMIT_TYPE
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "DTO.TRANSACTION.SEND.SUBMIT_TYPE",
    ///  "examples": [
    ///    "default"
    ///  ],
    ///  "type": "string",
    ///  "enum": [
    ///    "default",
    ///    "priority"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum SendTxInputSubmitType {
        #[serde(rename = "default")]
        Default,
        #[serde(rename = "priority")]
        Priority,
    }
    impl ::std::convert::From<&Self> for SendTxInputSubmitType {
        fn from(value: &SendTxInputSubmitType) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for SendTxInputSubmitType {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::Default => f.write_str("default"),
                Self::Priority => f.write_str("priority"),
            }
        }
    }
    impl ::std::str::FromStr for SendTxInputSubmitType {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "default" => Ok(Self::Default),
                "priority" => Ok(Self::Priority),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for SendTxInputSubmitType {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String> for SendTxInputSubmitType {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for SendTxInputSubmitType {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    ///`SendTxResponse`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "elapsedTime",
    ///    "jobId",
    ///    "signature"
    ///  ],
    ///  "properties": {
    ///    "elapsedTime": {
    ///      "description": "DTO.TRANSACTION.SEND.ELAPSED_TIME",
    ///      "examples": [
    ///        1500
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "jobId": {
    ///      "description": "DTO.TRANSACTION.SEND.JOB_ID",
    ///      "examples": [
    ///        "1234567890"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "signature": {
    ///      "description": "DTO.TRANSACTION.SEND.SIGNATURE",
    ///      "examples": [
    ///        "37XpPt9Ak6JiE1V3sftJDtdUsvR9FVFRqkZmoT3dp4BTD9pgyTWn1XgHH6R7NjuJ4pBMAgj8JvZtxQrf4s6NTC5F"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct SendTxResponse {
        ///DTO.TRANSACTION.SEND.ELAPSED_TIME
        #[serde(rename = "elapsedTime")]
        pub elapsed_time: i64,
        ///DTO.TRANSACTION.SEND.JOB_ID
        #[serde(rename = "jobId")]
        pub job_id: ::std::string::String,
        ///DTO.TRANSACTION.SEND.SIGNATURE
        pub signature: ::std::string::String,
    }
    impl ::std::convert::From<&SendTxResponse> for SendTxResponse {
        fn from(value: &SendTxResponse) -> Self {
            value.clone()
        }
    }
    impl SendTxResponse {
        pub fn builder() -> builder::SendTxResponse {
            Default::default()
        }
    }
    ///`SwapInput`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "amount",
    ///    "dex",
    ///    "slippage",
    ///    "swapMode",
    ///    "userAddress"
    ///  ],
    ///  "properties": {
    ///    "amount": {
    ///      "description": "DTO.DEX.SWAP.AMOUNT",
    ///      "examples": [
    ///        "1000000000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "dex": {
    ///      "description": "DTO.DEX.IDENTIFIER",
    ///      "examples": [
    ///        "raydium"
    ///      ],
    ///      "type": "string",
    ///      "enum": [
    ///        "raydium",
    ///        "pumpfun",
    ///        "moonshot",
    ///        "candy",
    ///        "launchpad"
    ///      ]
    ///    },
    ///    "inputMint": {
    ///      "description": "DTO.DEX.SWAP.INPUT_MINT",
    ///      "type": "string"
    ///    },
    ///    "outputMint": {
    ///      "description": "DTO.DEX.SWAP.OUTPUT_MINT",
    ///      "type": "string"
    ///    },
    ///    "poolAddress": {
    ///      "description": "DTO.DEX.SWAP.POOL_ADDRESS",
    ///      "examples": [
    ///        "58oQChx4yWmvKdwLLZzBi4ChoCc2fqCUWBkwMihLYQo2"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "priorityFee": {
    ///      "description": "DTO.DEX.BASE.PRIORITY_FEE",
    ///      "examples": [
    ///        "1000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "slippage": {
    ///      "description": "DTO.DEX.SWAP.SLIPPAGE",
    ///      "default": 10,
    ///      "examples": [
    ///        10
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64",
    ///      "maximum": 100.0,
    ///      "minimum": 0.0
    ///    },
    ///    "swapMode": {
    ///      "description": "DTO.DEX.SWAP.MODE",
    ///      "examples": [
    ///        "ExactIn"
    ///      ],
    ///      "type": "string",
    ///      "enum": [
    ///        "ExactIn",
    ///        "ExactOut"
    ///      ]
    ///    },
    ///    "userAddress": {
    ///      "description": "DTO.DEX.WALLET",
    ///      "examples": [
    ///        "oQPnhXAbLbMuKHESaGrbXT17CyvWCpLyERSJA9HCYd7"
    ///      ],
    ///      "type": "string",
    ///      "maxLength": 64,
    ///      "minLength": 8
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct SwapInput {
        ///DTO.DEX.SWAP.AMOUNT
        pub amount: ::std::string::String,
        ///DTO.DEX.IDENTIFIER
        pub dex: SwapInputDex,
        ///DTO.DEX.SWAP.INPUT_MINT
        #[serde(
            rename = "inputMint",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub input_mint: ::std::option::Option<::std::string::String>,
        ///DTO.DEX.SWAP.OUTPUT_MINT
        #[serde(
            rename = "outputMint",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub output_mint: ::std::option::Option<::std::string::String>,
        ///DTO.DEX.SWAP.POOL_ADDRESS
        #[serde(
            rename = "poolAddress",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub pool_address: ::std::option::Option<::std::string::String>,
        ///DTO.DEX.BASE.PRIORITY_FEE
        #[serde(
            rename = "priorityFee",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub priority_fee: ::std::option::Option<::std::string::String>,
        ///DTO.DEX.SWAP.SLIPPAGE
        pub slippage: i64,
        ///DTO.DEX.SWAP.MODE
        #[serde(rename = "swapMode")]
        pub swap_mode: SwapInputSwapMode,
        ///DTO.DEX.WALLET
        #[serde(rename = "userAddress")]
        pub user_address: SwapInputUserAddress,
    }
    impl ::std::convert::From<&SwapInput> for SwapInput {
        fn from(value: &SwapInput) -> Self {
            value.clone()
        }
    }
    impl SwapInput {
        pub fn builder() -> builder::SwapInput {
            Default::default()
        }
    }
    ///DTO.DEX.IDENTIFIER
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "DTO.DEX.IDENTIFIER",
    ///  "examples": [
    ///    "raydium"
    ///  ],
    ///  "type": "string",
    ///  "enum": [
    ///    "raydium",
    ///    "pumpfun",
    ///    "moonshot",
    ///    "candy",
    ///    "launchpad"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum SwapInputDex {
        #[serde(rename = "raydium")]
        Raydium,
        #[serde(rename = "pumpfun")]
        Pumpfun,
        #[serde(rename = "moonshot")]
        Moonshot,
        #[serde(rename = "candy")]
        Candy,
        #[serde(rename = "launchpad")]
        Launchpad,
    }
    impl ::std::convert::From<&Self> for SwapInputDex {
        fn from(value: &SwapInputDex) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for SwapInputDex {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::Raydium => f.write_str("raydium"),
                Self::Pumpfun => f.write_str("pumpfun"),
                Self::Moonshot => f.write_str("moonshot"),
                Self::Candy => f.write_str("candy"),
                Self::Launchpad => f.write_str("launchpad"),
            }
        }
    }
    impl ::std::str::FromStr for SwapInputDex {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "raydium" => Ok(Self::Raydium),
                "pumpfun" => Ok(Self::Pumpfun),
                "moonshot" => Ok(Self::Moonshot),
                "candy" => Ok(Self::Candy),
                "launchpad" => Ok(Self::Launchpad),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for SwapInputDex {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String> for SwapInputDex {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for SwapInputDex {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    ///DTO.DEX.SWAP.MODE
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "DTO.DEX.SWAP.MODE",
    ///  "examples": [
    ///    "ExactIn"
    ///  ],
    ///  "type": "string",
    ///  "enum": [
    ///    "ExactIn",
    ///    "ExactOut"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum SwapInputSwapMode {
        ExactIn,
        ExactOut,
    }
    impl ::std::convert::From<&Self> for SwapInputSwapMode {
        fn from(value: &SwapInputSwapMode) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for SwapInputSwapMode {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::ExactIn => f.write_str("ExactIn"),
                Self::ExactOut => f.write_str("ExactOut"),
            }
        }
    }
    impl ::std::str::FromStr for SwapInputSwapMode {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "ExactIn" => Ok(Self::ExactIn),
                "ExactOut" => Ok(Self::ExactOut),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for SwapInputSwapMode {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String> for SwapInputSwapMode {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for SwapInputSwapMode {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    ///DTO.DEX.WALLET
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "DTO.DEX.WALLET",
    ///  "examples": [
    ///    "oQPnhXAbLbMuKHESaGrbXT17CyvWCpLyERSJA9HCYd7"
    ///  ],
    ///  "type": "string",
    ///  "maxLength": 64,
    ///  "minLength": 8
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
    #[serde(transparent)]
    pub struct SwapInputUserAddress(::std::string::String);
    impl ::std::ops::Deref for SwapInputUserAddress {
        type Target = ::std::string::String;
        fn deref(&self) -> &::std::string::String {
            &self.0
        }
    }
    impl ::std::convert::From<SwapInputUserAddress> for ::std::string::String {
        fn from(value: SwapInputUserAddress) -> Self {
            value.0
        }
    }
    impl ::std::convert::From<&SwapInputUserAddress> for SwapInputUserAddress {
        fn from(value: &SwapInputUserAddress) -> Self {
            value.clone()
        }
    }
    impl ::std::str::FromStr for SwapInputUserAddress {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            if value.chars().count() > 64usize {
                return Err("longer than 64 characters".into());
            }
            if value.chars().count() < 8usize {
                return Err("shorter than 8 characters".into());
            }
            Ok(Self(value.to_string()))
        }
    }
    impl ::std::convert::TryFrom<&str> for SwapInputUserAddress {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String> for SwapInputUserAddress {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for SwapInputUserAddress {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl<'de> ::serde::Deserialize<'de> for SwapInputUserAddress {
        fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
        where
            D: ::serde::Deserializer<'de>,
        {
            ::std::string::String::deserialize(deserializer)?
                .parse()
                .map_err(|e: self::error::ConversionError| {
                    <D::Error as ::serde::de::Error>::custom(e.to_string())
                })
        }
    }
    ///`SwapReply`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "elapsedTime",
    ///    "serializedTx"
    ///  ],
    ///  "properties": {
    ///    "elapsedTime": {
    ///      "description": "DTO.DEX.SWAP.ELAPSED_TIME",
    ///      "examples": [
    ///        245
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "serializedTx": {
    ///      "description": "DTO.DEX.SWAP.SERIALIZED_TX",
    ///      "examples": [
    ///        "AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAEDRgYGpQEDAQIABQcICQoLDA0ODwAAAAAAAAAAAAAQERITFBUWFxgZGhscHR4fAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA="
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct SwapReply {
        ///DTO.DEX.SWAP.ELAPSED_TIME
        #[serde(rename = "elapsedTime")]
        pub elapsed_time: i64,
        ///DTO.DEX.SWAP.SERIALIZED_TX
        #[serde(rename = "serializedTx")]
        pub serialized_tx: ::std::string::String,
    }
    impl ::std::convert::From<&SwapReply> for SwapReply {
        fn from(value: &SwapReply) -> Self {
            value.clone()
        }
    }
    impl SwapReply {
        pub fn builder() -> builder::SwapReply {
            Default::default()
        }
    }
    ///`SwapRouteInput`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "amount",
    ///    "dex",
    ///    "slippage",
    ///    "swapMode",
    ///    "userAddress"
    ///  ],
    ///  "properties": {
    ///    "amount": {
    ///      "description": "DTO.DEX.SWAP.AMOUNT",
    ///      "examples": [
    ///        "1000000000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "deadline": {
    ///      "description": "DTO.DEX.SWAP.DEADLINE",
    ///      "examples": [
    ///        1716806400000
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "dex": {
    ///      "description": "DTO.DEX.IDENTIFIER",
    ///      "examples": [
    ///        "jupiter"
    ///      ],
    ///      "type": "string",
    ///      "enum": [
    ///        "jupiter",
    ///        "kyberswap"
    ///      ]
    ///    },
    ///    "inputMint": {
    ///      "description": "DTO.DEX.SWAP.INPUT_MINT",
    ///      "examples": [
    ///        "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "isAntiMev": {
    ///      "description": "DTO.DEX.BASE.IS_ANTI_MEV",
    ///      "default": false,
    ///      "examples": [
    ///        true
    ///      ],
    ///      "type": "boolean"
    ///    },
    ///    "outputMint": {
    ///      "description": "DTO.DEX.SWAP.OUTPUT_MINT",
    ///      "examples": [
    ///        "Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "permit": {
    ///      "description": "DTO.DEX.SWAP.PERMIT",
    ///      "examples": [
    ///        "66c85d1637257e890e581f724f69f4d4fc17eee156c0619c4719ed0c66eed0e9"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "priorityFee": {
    ///      "description": "DTO.DEX.BASE.PRIORITY_FEE",
    ///      "examples": [
    ///        "1000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "recipientAddress": {
    ///      "description": "DTO.DEX.SWAP.RECIPIENT_ADDRESS",
    ///      "examples": [
    ///        "0x0000000000000000000000000000000000000001"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "slippage": {
    ///      "description": "DTO.DEX.SWAP.SLIPPAGE",
    ///      "default": 5,
    ///      "examples": [
    ///        5
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64",
    ///      "maximum": 100.0,
    ///      "minimum": 0.0
    ///    },
    ///    "swapMode": {
    ///      "description": "DTO.DEX.SWAP.MODE",
    ///      "examples": [
    ///        "ExactIn"
    ///      ],
    ///      "type": "string",
    ///      "enum": [
    ///        "ExactIn",
    ///        "ExactOut"
    ///      ]
    ///    },
    ///    "tipFee": {
    ///      "description": "DTO.DEX.BASE.TIP_FEE",
    ///      "examples": [
    ///        "1000000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "userAddress": {
    ///      "description": "DTO.DEX.WALLET",
    ///      "examples": [
    ///        "oQPnhXAbLbMuKHESaGrbXT17CyvWCpLyERSJA9HCYd7"
    ///      ],
    ///      "type": "string",
    ///      "maxLength": 64,
    ///      "minLength": 8
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct SwapRouteInput {
        ///DTO.DEX.SWAP.AMOUNT
        pub amount: ::std::string::String,
        ///DTO.DEX.SWAP.DEADLINE
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub deadline: ::std::option::Option<i64>,
        ///DTO.DEX.IDENTIFIER
        pub dex: SwapRouteInputDex,
        ///DTO.DEX.SWAP.INPUT_MINT
        #[serde(
            rename = "inputMint",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub input_mint: ::std::option::Option<::std::string::String>,
        ///DTO.DEX.BASE.IS_ANTI_MEV
        #[serde(rename = "isAntiMev", default)]
        pub is_anti_mev: bool,
        ///DTO.DEX.SWAP.OUTPUT_MINT
        #[serde(
            rename = "outputMint",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub output_mint: ::std::option::Option<::std::string::String>,
        ///DTO.DEX.SWAP.PERMIT
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub permit: ::std::option::Option<::std::string::String>,
        ///DTO.DEX.BASE.PRIORITY_FEE
        #[serde(
            rename = "priorityFee",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub priority_fee: ::std::option::Option<::std::string::String>,
        ///DTO.DEX.SWAP.RECIPIENT_ADDRESS
        #[serde(
            rename = "recipientAddress",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub recipient_address: ::std::option::Option<::std::string::String>,
        ///DTO.DEX.SWAP.SLIPPAGE
        pub slippage: i64,
        ///DTO.DEX.SWAP.MODE
        #[serde(rename = "swapMode")]
        pub swap_mode: SwapRouteInputSwapMode,
        ///DTO.DEX.BASE.TIP_FEE
        #[serde(
            rename = "tipFee",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub tip_fee: ::std::option::Option<::std::string::String>,
        ///DTO.DEX.WALLET
        #[serde(rename = "userAddress")]
        pub user_address: SwapRouteInputUserAddress,
    }
    impl ::std::convert::From<&SwapRouteInput> for SwapRouteInput {
        fn from(value: &SwapRouteInput) -> Self {
            value.clone()
        }
    }
    impl SwapRouteInput {
        pub fn builder() -> builder::SwapRouteInput {
            Default::default()
        }
    }
    ///DTO.DEX.IDENTIFIER
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "DTO.DEX.IDENTIFIER",
    ///  "examples": [
    ///    "jupiter"
    ///  ],
    ///  "type": "string",
    ///  "enum": [
    ///    "jupiter",
    ///    "kyberswap"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum SwapRouteInputDex {
        #[serde(rename = "jupiter")]
        Jupiter,
        #[serde(rename = "kyberswap")]
        Kyberswap,
    }
    impl ::std::convert::From<&Self> for SwapRouteInputDex {
        fn from(value: &SwapRouteInputDex) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for SwapRouteInputDex {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::Jupiter => f.write_str("jupiter"),
                Self::Kyberswap => f.write_str("kyberswap"),
            }
        }
    }
    impl ::std::str::FromStr for SwapRouteInputDex {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "jupiter" => Ok(Self::Jupiter),
                "kyberswap" => Ok(Self::Kyberswap),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for SwapRouteInputDex {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String> for SwapRouteInputDex {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for SwapRouteInputDex {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    ///DTO.DEX.SWAP.MODE
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "DTO.DEX.SWAP.MODE",
    ///  "examples": [
    ///    "ExactIn"
    ///  ],
    ///  "type": "string",
    ///  "enum": [
    ///    "ExactIn",
    ///    "ExactOut"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum SwapRouteInputSwapMode {
        ExactIn,
        ExactOut,
    }
    impl ::std::convert::From<&Self> for SwapRouteInputSwapMode {
        fn from(value: &SwapRouteInputSwapMode) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for SwapRouteInputSwapMode {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::ExactIn => f.write_str("ExactIn"),
                Self::ExactOut => f.write_str("ExactOut"),
            }
        }
    }
    impl ::std::str::FromStr for SwapRouteInputSwapMode {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "ExactIn" => Ok(Self::ExactIn),
                "ExactOut" => Ok(Self::ExactOut),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for SwapRouteInputSwapMode {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String> for SwapRouteInputSwapMode {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for SwapRouteInputSwapMode {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    ///DTO.DEX.WALLET
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "DTO.DEX.WALLET",
    ///  "examples": [
    ///    "oQPnhXAbLbMuKHESaGrbXT17CyvWCpLyERSJA9HCYd7"
    ///  ],
    ///  "type": "string",
    ///  "maxLength": 64,
    ///  "minLength": 8
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
    #[serde(transparent)]
    pub struct SwapRouteInputUserAddress(::std::string::String);
    impl ::std::ops::Deref for SwapRouteInputUserAddress {
        type Target = ::std::string::String;
        fn deref(&self) -> &::std::string::String {
            &self.0
        }
    }
    impl ::std::convert::From<SwapRouteInputUserAddress> for ::std::string::String {
        fn from(value: SwapRouteInputUserAddress) -> Self {
            value.0
        }
    }
    impl ::std::convert::From<&SwapRouteInputUserAddress> for SwapRouteInputUserAddress {
        fn from(value: &SwapRouteInputUserAddress) -> Self {
            value.clone()
        }
    }
    impl ::std::str::FromStr for SwapRouteInputUserAddress {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            if value.chars().count() > 64usize {
                return Err("longer than 64 characters".into());
            }
            if value.chars().count() < 8usize {
                return Err("shorter than 8 characters".into());
            }
            Ok(Self(value.to_string()))
        }
    }
    impl ::std::convert::TryFrom<&str> for SwapRouteInputUserAddress {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String> for SwapRouteInputUserAddress {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for SwapRouteInputUserAddress {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl<'de> ::serde::Deserialize<'de> for SwapRouteInputUserAddress {
        fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
        where
            D: ::serde::Deserializer<'de>,
        {
            ::std::string::String::deserialize(deserializer)?
                .parse()
                .map_err(|e: self::error::ConversionError| {
                    <D::Error as ::serde::de::Error>::custom(e.to_string())
                })
        }
    }
    ///`SwapRouteResponse`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "args",
    ///    "elapsedTime",
    ///    "routeInfo",
    ///    "serializedTx"
    ///  ],
    ///  "properties": {
    ///    "args": {
    ///      "description": "DTO.DEX.SWAP.ARGS",
    ///      "allOf": [
    ///        {
    ///          "$ref": "#/components/schemas/SwapRouteInput"
    ///        }
    ///      ]
    ///    },
    ///    "elapsedTime": {
    ///      "description": "DTO.DEX.SWAP.ELAPSED_TIME",
    ///      "examples": [
    ///        245
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "routeInfo": {
    ///      "description": "DTO.DEX.SWAP.ROUTE_INFO",
    ///      "examples": [
    ///        {
    ///          "inAmount": "1000000000",
    ///          "outAmount": "985000000",
    ///          "priceImpact": "0.15",
    ///          "route": [
    ///            "USDC",
    ///            "SOL"
    ///          ]
    ///        }
    ///      ],
    ///      "type": "object"
    ///    },
    ///    "serializedTx": {
    ///      "description": "DTO.DEX.SWAP.SERIALIZED_TX",
    ///      "examples": [
    ///        "AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAEDRgYGpQEDAQIABQcICQoLDA0ODwAAAAAAAAAAAAAQERITFBUWFxgZGhscHR4fAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA="
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct SwapRouteResponse {
        ///DTO.DEX.SWAP.ARGS
        pub args: SwapRouteInput,
        ///DTO.DEX.SWAP.ELAPSED_TIME
        #[serde(rename = "elapsedTime")]
        pub elapsed_time: i64,
        ///DTO.DEX.SWAP.ROUTE_INFO
        #[serde(rename = "routeInfo")]
        pub route_info: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
        ///DTO.DEX.SWAP.SERIALIZED_TX
        #[serde(rename = "serializedTx")]
        pub serialized_tx: ::std::string::String,
    }
    impl ::std::convert::From<&SwapRouteResponse> for SwapRouteResponse {
        fn from(value: &SwapRouteResponse) -> Self {
            value.clone()
        }
    }
    impl SwapRouteResponse {
        pub fn builder() -> builder::SwapRouteResponse {
            Default::default()
        }
    }
    ///`Token`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "address",
    ///    "chain",
    ///    "decimals",
    ///    "marketData",
    ///    "name",
    ///    "symbol"
    ///  ],
    ///  "properties": {
    ///    "address": {
    ///      "description": "DTO.TOKEN.METADATA.ADDRESS",
    ///      "examples": [
    ///        "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "chain": {
    ///      "description": "DTO.TOKEN.METADATA.CHAIN",
    ///      "examples": [
    ///        "solana"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "coingeckoCoinId": {
    ///      "description": "DTO.TOKEN.METADATA.COINGECKO_COIN_ID",
    ///      "examples": [
    ///        "usd-coin"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "decimals": {
    ///      "description": "DTO.TOKEN.METADATA.DECIMALS",
    ///      "examples": [
    ///        9
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "description": {
    ///      "description": "DTO.TOKEN.METADATA.DESCRIPTION",
    ///      "examples": [
    ///        "USDC is a stablecoin pegged to the US dollar"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "devLastTokenCreatedAt": {
    ///      "description": "DTO.TOKEN.METADATA.DEV_LAST_TOKEN_CREATED_AT",
    ///      "examples": [
    ///        "2025-12-03T09:23:34.000Z"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "devTotalTokens": {
    ///      "description": "DTO.TOKEN.METADATA.DEV_TOTAL_TOKENS",
    ///      "examples": [
    ///        "163"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "extension": {
    ///      "description": "DTO.TOKEN.EXTENSION",
    ///      "examples": [
    ///        {
    ///          "twitter": "@circle",
    ///          "website": "https://www.circle.com/usdc"
    ///        }
    ///      ],
    ///      "type": "object"
    ///    },
    ///    "extra": {
    ///      "description": "DTO.TOKEN.METADATA.EXTRA",
    ///      "allOf": [
    ///        {
    ///          "$ref": "#/components/schemas/TokenExtraDTO"
    ///        }
    ///      ]
    ///    },
    ///    "imageUrl": {
    ///      "description": "DTO.TOKEN.METADATA.IMAGE_URL",
    ///      "examples": [
    ///        "https://raw.githubusercontent.com/solana-labs/token-list/main/assets/mainnet/EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v/logo.png"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "liquidity": {
    ///      "description": "DTO.TOKEN.LIQUIDITY",
    ///      "type": "array",
    ///      "items": {
    ///        "$ref": "#/components/schemas/DexPoolDTO"
    ///      }
    ///    },
    ///    "market": {
    ///      "description": "DTO.TOKEN.MARKET_ID",
    ///      "examples": [
    ///        "USDC-SOL"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "marketData": {
    ///      "description": "DTO.TOKEN.MARKET_CAP_INFO",
    ///      "allOf": [
    ///        {
    ///          "$ref": "#/components/schemas/TokenMarketData"
    ///        }
    ///      ]
    ///    },
    ///    "metadataAddress": {
    ///      "description": "DTO.TOKEN.METADATA.METADATA_ADDRESS",
    ///      "examples": [
    ///        "metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "name": {
    ///      "description": "DTO.TOKEN.METADATA.NAME",
    ///      "examples": [
    ///        "USD Coin"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "socialMedias": {
    ///      "description": "DTO.TOKEN.METADATA.SOCIAL_MEDIAS",
    ///      "allOf": [
    ///        {
    ///          "$ref": "#/components/schemas/TokenSocialMediasDTO"
    ///        }
    ///      ]
    ///    },
    ///    "stats": {
    ///      "description": "DTO.TOKEN.STATS",
    ///      "allOf": [
    ///        {
    ///          "$ref": "#/components/schemas/TokenStat"
    ///        }
    ///      ]
    ///    },
    ///    "symbol": {
    ///      "description": "DTO.TOKEN.METADATA.SYMBOL",
    ///      "examples": [
    ///        "USDC"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "tokenCreatedAt": {
    ///      "description": "DTO.TOKEN.METADATA.TOKEN_CREATED_AT",
    ///      "examples": [
    ///        1710417600000
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "tokenCreatedBlockHeight": {
    ///      "description": "DTO.TOKEN.METADATA.TOKEN_CREATED_BLOCK_HEIGHT",
    ///      "examples": [
    ///        "220000000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "tokenCreatedSlot": {
    ///      "description": "DTO.TOKEN.METADATA.TOKEN_CREATED_SLOT",
    ///      "examples": [
    ///        "230000000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "tokenCreatedTxSignature": {
    ///      "description": "DTO.TOKEN.METADATA.TOKEN_CREATED_TX_SIGNATURE",
    ///      "examples": [
    ///        "5dJ1BxPiFT7w7aBdkxNy2jopGZnZoLwRwS8e9GkEXrVz..."
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "tokenCreators": {
    ///      "description": "DTO.TOKEN.METADATA.TOKEN_CREATORS",
    ///      "type": "array",
    ///      "items": {
    ///        "$ref": "#/components/schemas/TokenCreatorsDTO"
    ///      }
    ///    },
    ///    "uri": {
    ///      "description": "DTO.TOKEN.METADATA.URI",
    ///      "examples": [
    ///        "https://..."
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct Token {
        ///DTO.TOKEN.METADATA.ADDRESS
        pub address: ::std::string::String,
        ///DTO.TOKEN.METADATA.CHAIN
        pub chain: ::std::string::String,
        ///DTO.TOKEN.METADATA.COINGECKO_COIN_ID
        #[serde(
            rename = "coingeckoCoinId",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub coingecko_coin_id: ::std::option::Option<::std::string::String>,
        ///DTO.TOKEN.METADATA.DECIMALS
        pub decimals: i64,
        ///DTO.TOKEN.METADATA.DESCRIPTION
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub description: ::std::option::Option<::std::string::String>,
        ///DTO.TOKEN.METADATA.DEV_LAST_TOKEN_CREATED_AT
        #[serde(
            rename = "devLastTokenCreatedAt",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub dev_last_token_created_at: ::std::option::Option<::std::string::String>,
        ///DTO.TOKEN.METADATA.DEV_TOTAL_TOKENS
        #[serde(
            rename = "devTotalTokens",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub dev_total_tokens: ::std::option::Option<::std::string::String>,
        ///DTO.TOKEN.EXTENSION
        #[serde(default, skip_serializing_if = "::serde_json::Map::is_empty")]
        pub extension: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
        ///DTO.TOKEN.METADATA.EXTRA
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub extra: ::std::option::Option<TokenExtraDto>,
        ///DTO.TOKEN.METADATA.IMAGE_URL
        #[serde(
            rename = "imageUrl",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub image_url: ::std::option::Option<::std::string::String>,
        ///DTO.TOKEN.LIQUIDITY
        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
        pub liquidity: ::std::vec::Vec<DexPoolDto>,
        ///DTO.TOKEN.MARKET_ID
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub market: ::std::option::Option<::std::string::String>,
        ///DTO.TOKEN.MARKET_CAP_INFO
        #[serde(rename = "marketData")]
        pub market_data: TokenMarketData,
        ///DTO.TOKEN.METADATA.METADATA_ADDRESS
        #[serde(
            rename = "metadataAddress",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub metadata_address: ::std::option::Option<::std::string::String>,
        ///DTO.TOKEN.METADATA.NAME
        pub name: ::std::string::String,
        ///DTO.TOKEN.METADATA.SOCIAL_MEDIAS
        #[serde(
            rename = "socialMedias",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub social_medias: ::std::option::Option<TokenSocialMediasDto>,
        ///DTO.TOKEN.STATS
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub stats: ::std::option::Option<TokenStat>,
        ///DTO.TOKEN.METADATA.SYMBOL
        pub symbol: ::std::string::String,
        ///DTO.TOKEN.METADATA.TOKEN_CREATED_AT
        #[serde(
            rename = "tokenCreatedAt",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub token_created_at: ::std::option::Option<i64>,
        ///DTO.TOKEN.METADATA.TOKEN_CREATED_BLOCK_HEIGHT
        #[serde(
            rename = "tokenCreatedBlockHeight",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub token_created_block_height: ::std::option::Option<::std::string::String>,
        ///DTO.TOKEN.METADATA.TOKEN_CREATED_SLOT
        #[serde(
            rename = "tokenCreatedSlot",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub token_created_slot: ::std::option::Option<::std::string::String>,
        ///DTO.TOKEN.METADATA.TOKEN_CREATED_TX_SIGNATURE
        #[serde(
            rename = "tokenCreatedTxSignature",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub token_created_tx_signature: ::std::option::Option<::std::string::String>,
        ///DTO.TOKEN.METADATA.TOKEN_CREATORS
        #[serde(
            rename = "tokenCreators",
            default,
            skip_serializing_if = "::std::vec::Vec::is_empty"
        )]
        pub token_creators: ::std::vec::Vec<TokenCreatorsDto>,
        ///DTO.TOKEN.METADATA.URI
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub uri: ::std::option::Option<::std::string::String>,
    }
    impl ::std::convert::From<&Token> for Token {
        fn from(value: &Token) -> Self {
            value.clone()
        }
    }
    impl Token {
        pub fn builder() -> builder::Token {
            Default::default()
        }
    }
    ///`TokenCreationDto`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "blockHash",
    ///    "blockHeight",
    ///    "blockSlot",
    ///    "tokenAddress",
    ///    "transactionSignature",
    ///    "type"
    ///  ],
    ///  "properties": {
    ///    "blockHash": {
    ///      "description": "DTO.TOKEN.CREATION.BLOCK_HASH",
    ///      "examples": [
    ///        "5J7X9K2M4N6P8Q"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "blockHeight": {
    ///      "description": "DTO.TOKEN.CREATION.BLOCK_HEIGHT",
    ///      "examples": [
    ///        123456789
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "blockSlot": {
    ///      "description": "DTO.TOKEN.CREATION.BLOCK_SLOT",
    ///      "examples": [
    ///        123456789
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "blockTimestamp": {
    ///      "description": "DTO.TOKEN.CREATION.BLOCK_TIMESTAMP",
    ///      "examples": [
    ///        1754055151000
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "tokenAddress": {
    ///      "description": "DTO.TOKEN.CREATION.TOKEN_ADDRESS",
    ///      "examples": [
    ///        "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "transactionSignature": {
    ///      "description": "DTO.TOKEN.CREATION.TRANSACTION_SIGNATURE",
    ///      "examples": [
    ///        "3A7B9C1D2E4F6G8"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "type": {
    ///      "description": "DTO.TOKEN.CREATION.TYPE",
    ///      "examples": [
    ///        "create"
    ///      ],
    ///      "type": "string",
    ///      "enum": [
    ///        "create",
    ///        "mint",
    ///        "burn"
    ///      ]
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct TokenCreationDto {
        ///DTO.TOKEN.CREATION.BLOCK_HASH
        #[serde(rename = "blockHash")]
        pub block_hash: ::std::string::String,
        ///DTO.TOKEN.CREATION.BLOCK_HEIGHT
        #[serde(rename = "blockHeight")]
        pub block_height: i64,
        ///DTO.TOKEN.CREATION.BLOCK_SLOT
        #[serde(rename = "blockSlot")]
        pub block_slot: i64,
        ///DTO.TOKEN.CREATION.BLOCK_TIMESTAMP
        #[serde(
            rename = "blockTimestamp",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub block_timestamp: ::std::option::Option<i64>,
        ///DTO.TOKEN.CREATION.TOKEN_ADDRESS
        #[serde(rename = "tokenAddress")]
        pub token_address: ::std::string::String,
        ///DTO.TOKEN.CREATION.TRANSACTION_SIGNATURE
        #[serde(rename = "transactionSignature")]
        pub transaction_signature: ::std::string::String,
        ///DTO.TOKEN.CREATION.TYPE
        #[serde(rename = "type")]
        pub type_: TokenCreationDtoType,
    }
    impl ::std::convert::From<&TokenCreationDto> for TokenCreationDto {
        fn from(value: &TokenCreationDto) -> Self {
            value.clone()
        }
    }
    impl TokenCreationDto {
        pub fn builder() -> builder::TokenCreationDto {
            Default::default()
        }
    }
    ///DTO.TOKEN.CREATION.TYPE
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "DTO.TOKEN.CREATION.TYPE",
    ///  "examples": [
    ///    "create"
    ///  ],
    ///  "type": "string",
    ///  "enum": [
    ///    "create",
    ///    "mint",
    ///    "burn"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum TokenCreationDtoType {
        #[serde(rename = "create")]
        Create,
        #[serde(rename = "mint")]
        Mint,
        #[serde(rename = "burn")]
        Burn,
    }
    impl ::std::convert::From<&Self> for TokenCreationDtoType {
        fn from(value: &TokenCreationDtoType) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for TokenCreationDtoType {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::Create => f.write_str("create"),
                Self::Mint => f.write_str("mint"),
                Self::Burn => f.write_str("burn"),
            }
        }
    }
    impl ::std::str::FromStr for TokenCreationDtoType {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "create" => Ok(Self::Create),
                "mint" => Ok(Self::Mint),
                "burn" => Ok(Self::Burn),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for TokenCreationDtoType {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String> for TokenCreationDtoType {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for TokenCreationDtoType {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    ///`TokenCreationPage`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "data"
    ///  ],
    ///  "properties": {
    ///    "data": {
    ///      "description": "DTO.TOKEN.CREATION.PAGE.DATA",
    ///      "type": "array",
    ///      "items": {
    ///        "$ref": "#/components/schemas/TokenCreationDTO"
    ///      }
    ///    },
    ///    "endCursor": {
    ///      "description": "DTO.PAGE.END_CURSOR",
    ///      "type": "string"
    ///    },
    ///    "hasNext": {
    ///      "description": "DTO.PAGE.HAS_NEXT",
    ///      "default": false,
    ///      "type": "boolean"
    ///    },
    ///    "hasPrev": {
    ///      "description": "DTO.PAGE.HAS_PREV",
    ///      "default": false,
    ///      "type": "boolean"
    ///    },
    ///    "startCursor": {
    ///      "description": "DTO.PAGE.START_CURSOR",
    ///      "type": "string"
    ///    },
    ///    "total": {
    ///      "description": "DTO.PAGE.TOTAL",
    ///      "default": 0,
    ///      "type": "integer",
    ///      "format": "int64"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct TokenCreationPage {
        ///DTO.TOKEN.CREATION.PAGE.DATA
        pub data: ::std::vec::Vec<TokenCreationDto>,
        ///DTO.PAGE.END_CURSOR
        #[serde(
            rename = "endCursor",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub end_cursor: ::std::option::Option<::std::string::String>,
        ///DTO.PAGE.HAS_NEXT
        #[serde(rename = "hasNext", default)]
        pub has_next: bool,
        ///DTO.PAGE.HAS_PREV
        #[serde(rename = "hasPrev", default)]
        pub has_prev: bool,
        ///DTO.PAGE.START_CURSOR
        #[serde(
            rename = "startCursor",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub start_cursor: ::std::option::Option<::std::string::String>,
        ///DTO.PAGE.TOTAL
        #[serde(default)]
        pub total: i64,
    }
    impl ::std::convert::From<&TokenCreationPage> for TokenCreationPage {
        fn from(value: &TokenCreationPage) -> Self {
            value.clone()
        }
    }
    impl TokenCreationPage {
        pub fn builder() -> builder::TokenCreationPage {
            Default::default()
        }
    }
    ///`TokenCreatorsDto`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "properties": {
    ///    "address": {
    ///      "description": "DTO.TOKEN.CREATORS.ADDRESS",
    ///      "examples": [
    ///        "5e2qRc1DNEXmyxP8qwPwJhRWjef7usLyi7v5xjqLr5G7"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "isVerified": {
    ///      "description": "DTO.TOKEN.CREATORS.IS_VERIFIED",
    ///      "examples": [
    ///        true
    ///      ],
    ///      "type": "boolean"
    ///    },
    ///    "share": {
    ///      "description": "DTO.TOKEN.CREATORS.SHARE",
    ///      "examples": [
    ///        100
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct TokenCreatorsDto {
        ///DTO.TOKEN.CREATORS.ADDRESS
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub address: ::std::option::Option<::std::string::String>,
        ///DTO.TOKEN.CREATORS.IS_VERIFIED
        #[serde(
            rename = "isVerified",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub is_verified: ::std::option::Option<bool>,
        ///DTO.TOKEN.CREATORS.SHARE
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub share: ::std::option::Option<i64>,
    }
    impl ::std::convert::From<&TokenCreatorsDto> for TokenCreatorsDto {
        fn from(value: &TokenCreatorsDto) -> Self {
            value.clone()
        }
    }
    impl ::std::default::Default for TokenCreatorsDto {
        fn default() -> Self {
            Self {
                address: Default::default(),
                is_verified: Default::default(),
                share: Default::default(),
            }
        }
    }
    impl TokenCreatorsDto {
        pub fn builder() -> builder::TokenCreatorsDto {
            Default::default()
        }
    }
    ///`TokenExtraDto`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "properties": {
    ///    "collectionAddress": {
    ///      "description": "DTO.TOKEN.EXTRA.COLLECTION_ADDRESS",
    ///      "examples": [
    ///        "ABCDE"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "editionNonce": {
    ///      "description": "DTO.TOKEN.EXTRA.EDITION_NONCE",
    ///      "examples": [
    ///        1
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "freezeAuthority": {
    ///      "description": "DTO.TOKEN.EXTRA.FREEZE_AUTHORITY",
    ///      "examples": [
    ///        "B61ZzjjZskE9yur2CBe4H4NFS3XHdEZdatKNegC9smUV"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "fungible": {
    ///      "description": "DTO.TOKEN.EXTRA.FUNGIBLE",
    ///      "examples": [
    ///        true
    ///      ],
    ///      "type": "boolean"
    ///    },
    ///    "isMutable": {
    ///      "description": "DTO.TOKEN.EXTRA.IS_MUTABLE",
    ///      "examples": [
    ///        true
    ///      ],
    ///      "type": "boolean"
    ///    },
    ///    "isNative": {
    ///      "description": "DTO.TOKEN.EXTRA.IS_NATIVE",
    ///      "examples": [
    ///        false
    ///      ],
    ///      "type": "boolean"
    ///    },
    ///    "isVerifiedCollection": {
    ///      "description": "DTO.TOKEN.EXTRA.IS_VERIFIED_COLLECTION",
    ///      "examples": [
    ///        true
    ///      ],
    ///      "type": "boolean"
    ///    },
    ///    "isWrapped": {
    ///      "description": "DTO.TOKEN.EXTRA.IS_WRAPPED",
    ///      "examples": [
    ///        false
    ///      ],
    ///      "type": "boolean"
    ///    },
    ///    "key": {
    ///      "description": "DTO.TOKEN.EXTRA.KEY",
    ///      "examples": [
    ///        "Mint"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "launchFromProgramAddress": {
    ///      "description": "DTO.TOKEN.EXTRA.LAUNCH_FROM_PROGRAM_ADDRESS",
    ///      "examples": [
    ///        "6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "launchFromProtocolFamily": {
    ///      "description": "DTO.TOKEN.EXTRA.LAUNCH_FROM_PROTOCOL_FAMILY",
    ///      "examples": [
    ///        "pumpfun"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "migratedAt": {
    ///      "description": "DTO.TOKEN.EXTRA.MIGRATED_AT",
    ///      "examples": [
    ///        1714857600000
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "migratedToPoolAddress": {
    ///      "description": "DTO.TOKEN.EXTRA.MIGRATED_TO_POOL_ADDRESS",
    ///      "examples": [
    ///        "7AvUMqLBou5EAXzyhnizWmPU13u2VguJoBYdcX4bhJtQ"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "migratedToProgramAddress": {
    ///      "description": "DTO.TOKEN.EXTRA.MIGRATED_TO_PROGRAM_ADDRESS",
    ///      "examples": [
    ///        "pAMMBay6oceH9fJKBRHGP5D4bD4sWpmSwMn52FMfXEA"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "migratedToProtocolFamily": {
    ///      "description": "DTO.TOKEN.EXTRA.MIGRATED_TO_PROTOCOL_FAMILY",
    ///      "examples": [
    ///        "Raydium"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "mintAuthority": {
    ///      "description": "DTO.TOKEN.EXTRA.MINT_AUTHORITY",
    ///      "examples": [
    ///        "B61ZzjjZskE9yur2CBe4H4NFS3XHdEZdatKNegC9smUV"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "primarySaleHappened": {
    ///      "description": "DTO.TOKEN.EXTRA.PRIMARY_SALE_HAPPENED",
    ///      "examples": [
    ///        false
    ///      ],
    ///      "type": "boolean"
    ///    },
    ///    "programAddress": {
    ///      "description": "DTO.TOKEN.EXTRA.PROGRAM_ADDRESS",
    ///      "examples": [
    ///        "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "sellerFeeBasisPoints": {
    ///      "description": "DTO.TOKEN.EXTRA.SELLER_FEE_BASIS_POINTS",
    ///      "examples": [
    ///        100
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "tokenStandard": {
    ///      "description": "DTO.TOKEN.EXTRA.TOKEN_STANDARD",
    ///      "examples": [
    ///        "Fungible"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "updateAuthority": {
    ///      "description": "DTO.TOKEN.EXTRA.UPDATE_AUTHORITY",
    ///      "examples": [
    ///        "B61ZzjjZskE9yur2CBe4H4NFS3XHdEZdatKNegC9smUV"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct TokenExtraDto {
        ///DTO.TOKEN.EXTRA.COLLECTION_ADDRESS
        #[serde(
            rename = "collectionAddress",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub collection_address: ::std::option::Option<::std::string::String>,
        ///DTO.TOKEN.EXTRA.EDITION_NONCE
        #[serde(
            rename = "editionNonce",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub edition_nonce: ::std::option::Option<i64>,
        ///DTO.TOKEN.EXTRA.FREEZE_AUTHORITY
        #[serde(
            rename = "freezeAuthority",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub freeze_authority: ::std::option::Option<::std::string::String>,
        ///DTO.TOKEN.EXTRA.FUNGIBLE
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub fungible: ::std::option::Option<bool>,
        ///DTO.TOKEN.EXTRA.IS_MUTABLE
        #[serde(
            rename = "isMutable",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub is_mutable: ::std::option::Option<bool>,
        ///DTO.TOKEN.EXTRA.IS_NATIVE
        #[serde(
            rename = "isNative",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub is_native: ::std::option::Option<bool>,
        ///DTO.TOKEN.EXTRA.IS_VERIFIED_COLLECTION
        #[serde(
            rename = "isVerifiedCollection",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub is_verified_collection: ::std::option::Option<bool>,
        ///DTO.TOKEN.EXTRA.IS_WRAPPED
        #[serde(
            rename = "isWrapped",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub is_wrapped: ::std::option::Option<bool>,
        ///DTO.TOKEN.EXTRA.KEY
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub key: ::std::option::Option<::std::string::String>,
        ///DTO.TOKEN.EXTRA.LAUNCH_FROM_PROGRAM_ADDRESS
        #[serde(
            rename = "launchFromProgramAddress",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub launch_from_program_address: ::std::option::Option<::std::string::String>,
        ///DTO.TOKEN.EXTRA.LAUNCH_FROM_PROTOCOL_FAMILY
        #[serde(
            rename = "launchFromProtocolFamily",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub launch_from_protocol_family: ::std::option::Option<::std::string::String>,
        ///DTO.TOKEN.EXTRA.MIGRATED_AT
        #[serde(
            rename = "migratedAt",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub migrated_at: ::std::option::Option<i64>,
        ///DTO.TOKEN.EXTRA.MIGRATED_TO_POOL_ADDRESS
        #[serde(
            rename = "migratedToPoolAddress",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub migrated_to_pool_address: ::std::option::Option<::std::string::String>,
        ///DTO.TOKEN.EXTRA.MIGRATED_TO_PROGRAM_ADDRESS
        #[serde(
            rename = "migratedToProgramAddress",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub migrated_to_program_address: ::std::option::Option<::std::string::String>,
        ///DTO.TOKEN.EXTRA.MIGRATED_TO_PROTOCOL_FAMILY
        #[serde(
            rename = "migratedToProtocolFamily",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub migrated_to_protocol_family: ::std::option::Option<::std::string::String>,
        ///DTO.TOKEN.EXTRA.MINT_AUTHORITY
        #[serde(
            rename = "mintAuthority",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub mint_authority: ::std::option::Option<::std::string::String>,
        ///DTO.TOKEN.EXTRA.PRIMARY_SALE_HAPPENED
        #[serde(
            rename = "primarySaleHappened",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub primary_sale_happened: ::std::option::Option<bool>,
        ///DTO.TOKEN.EXTRA.PROGRAM_ADDRESS
        #[serde(
            rename = "programAddress",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub program_address: ::std::option::Option<::std::string::String>,
        ///DTO.TOKEN.EXTRA.SELLER_FEE_BASIS_POINTS
        #[serde(
            rename = "sellerFeeBasisPoints",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub seller_fee_basis_points: ::std::option::Option<i64>,
        ///DTO.TOKEN.EXTRA.TOKEN_STANDARD
        #[serde(
            rename = "tokenStandard",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub token_standard: ::std::option::Option<::std::string::String>,
        ///DTO.TOKEN.EXTRA.UPDATE_AUTHORITY
        #[serde(
            rename = "updateAuthority",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub update_authority: ::std::option::Option<::std::string::String>,
    }
    impl ::std::convert::From<&TokenExtraDto> for TokenExtraDto {
        fn from(value: &TokenExtraDto) -> Self {
            value.clone()
        }
    }
    impl ::std::default::Default for TokenExtraDto {
        fn default() -> Self {
            Self {
                collection_address: Default::default(),
                edition_nonce: Default::default(),
                freeze_authority: Default::default(),
                fungible: Default::default(),
                is_mutable: Default::default(),
                is_native: Default::default(),
                is_verified_collection: Default::default(),
                is_wrapped: Default::default(),
                key: Default::default(),
                launch_from_program_address: Default::default(),
                launch_from_protocol_family: Default::default(),
                migrated_at: Default::default(),
                migrated_to_pool_address: Default::default(),
                migrated_to_program_address: Default::default(),
                migrated_to_protocol_family: Default::default(),
                mint_authority: Default::default(),
                primary_sale_happened: Default::default(),
                program_address: Default::default(),
                seller_fee_basis_points: Default::default(),
                token_standard: Default::default(),
                update_authority: Default::default(),
            }
        }
    }
    impl TokenExtraDto {
        pub fn builder() -> builder::TokenExtraDto {
            Default::default()
        }
    }
    ///`TokenHolder`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "amount",
    ///    "amountInUsd",
    ///    "percentage",
    ///    "walletAddress"
    ///  ],
    ///  "properties": {
    ///    "amount": {
    ///      "description": "DTO.TOKEN_HOLDER.AMOUNT",
    ///      "examples": [
    ///        "1000000000000000000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "amountInUsd": {
    ///      "description": "DTO.TOKEN_HOLDER.AMOUNT_USD",
    ///      "examples": [
    ///        "1000000000000000000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "percentage": {
    ///      "description": "DTO.TOKEN_HOLDER.PERCENTAGE",
    ///      "examples": [
    ///        "100"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "walletAddress": {
    ///      "description": "DTO.TOKEN_HOLDER.WALLET_ADDRESS",
    ///      "examples": [
    ///        "0x1234567890abcdef"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct TokenHolder {
        ///DTO.TOKEN_HOLDER.AMOUNT
        pub amount: ::std::string::String,
        ///DTO.TOKEN_HOLDER.AMOUNT_USD
        #[serde(rename = "amountInUsd")]
        pub amount_in_usd: ::std::string::String,
        ///DTO.TOKEN_HOLDER.PERCENTAGE
        pub percentage: ::std::string::String,
        ///DTO.TOKEN_HOLDER.WALLET_ADDRESS
        #[serde(rename = "walletAddress")]
        pub wallet_address: ::std::string::String,
    }
    impl ::std::convert::From<&TokenHolder> for TokenHolder {
        fn from(value: &TokenHolder) -> Self {
            value.clone()
        }
    }
    impl TokenHolder {
        pub fn builder() -> builder::TokenHolder {
            Default::default()
        }
    }
    ///`TokenHolderPage`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "data"
    ///  ],
    ///  "properties": {
    ///    "data": {
    ///      "description": "DTO.TOKEN_HOLDER.PAGE.DATA",
    ///      "type": "array",
    ///      "items": {
    ///        "$ref": "#/components/schemas/TokenHolder"
    ///      }
    ///    },
    ///    "endCursor": {
    ///      "description": "DTO.PAGE.END_CURSOR",
    ///      "type": "string"
    ///    },
    ///    "hasNext": {
    ///      "description": "DTO.PAGE.HAS_NEXT",
    ///      "default": false,
    ///      "type": "boolean"
    ///    },
    ///    "hasPrev": {
    ///      "description": "DTO.PAGE.HAS_PREV",
    ///      "default": false,
    ///      "type": "boolean"
    ///    },
    ///    "startCursor": {
    ///      "description": "DTO.PAGE.START_CURSOR",
    ///      "type": "string"
    ///    },
    ///    "total": {
    ///      "description": "DTO.PAGE.TOTAL",
    ///      "default": 0,
    ///      "type": "integer",
    ///      "format": "int64"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct TokenHolderPage {
        ///DTO.TOKEN_HOLDER.PAGE.DATA
        pub data: ::std::vec::Vec<TokenHolder>,
        ///DTO.PAGE.END_CURSOR
        #[serde(
            rename = "endCursor",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub end_cursor: ::std::option::Option<::std::string::String>,
        ///DTO.PAGE.HAS_NEXT
        #[serde(rename = "hasNext", default)]
        pub has_next: bool,
        ///DTO.PAGE.HAS_PREV
        #[serde(rename = "hasPrev", default)]
        pub has_prev: bool,
        ///DTO.PAGE.START_CURSOR
        #[serde(
            rename = "startCursor",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub start_cursor: ::std::option::Option<::std::string::String>,
        ///DTO.PAGE.TOTAL
        #[serde(default)]
        pub total: i64,
    }
    impl ::std::convert::From<&TokenHolderPage> for TokenHolderPage {
        fn from(value: &TokenHolderPage) -> Self {
            value.clone()
        }
    }
    impl TokenHolderPage {
        pub fn builder() -> builder::TokenHolderPage {
            Default::default()
        }
    }
    ///`TokenLiquiditySnapshotDto`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "calculatedAt",
    ///    "maxLiquidityInNative",
    ///    "maxLiquidityInUsd",
    ///    "maxLiquidityPoolAddress",
    ///    "poolCount",
    ///    "priceNative",
    ///    "priceUsd",
    ///    "snapshotTime",
    ///    "totalLiquidityInNative",
    ///    "totalLiquidityInUsd"
    ///  ],
    ///  "properties": {
    ///    "calculatedAt": {
    ///      "description": "DTO.TOKEN.LIQUIDITY_SNAPSHOT.CALCULATED_AT",
    ///      "examples": [
    ///        1705312800000
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "maxLiquidityInNative": {
    ///      "description": "DTO.TOKEN.LIQUIDITY_SNAPSHOT.MAX_LIQUIDITY_IN_NATIVE",
    ///      "examples": [
    ///        "5000.123"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "maxLiquidityInUsd": {
    ///      "description": "DTO.TOKEN.LIQUIDITY_SNAPSHOT.MAX_LIQUIDITY_IN_USD",
    ///      "examples": [
    ///        "1000000.45"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "maxLiquidityPoolAddress": {
    ///      "description": "DTO.TOKEN.LIQUIDITY_SNAPSHOT.MAX_LIQUIDITY_POOL_ADDRESS",
    ///      "examples": [
    ///        "58oQChx4yWmvKdwLLZzBi4ChoCc2fqCUWBkwMihLYQo2"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "poolCount": {
    ///      "description": "DTO.TOKEN.LIQUIDITY_SNAPSHOT.POOL_COUNT",
    ///      "examples": [
    ///        5
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "priceNative": {
    ///      "description": "DTO.TOKEN.LIQUIDITY_SNAPSHOT.PRICE_NATIVE",
    ///      "examples": [
    ///        "0.005"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "priceUsd": {
    ///      "description": "DTO.TOKEN.LIQUIDITY_SNAPSHOT.PRICE_USD",
    ///      "examples": [
    ///        "1.0001"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "snapshotTime": {
    ///      "description": "DTO.TOKEN.LIQUIDITY_SNAPSHOT.SNAPSHOT_TIME",
    ///      "examples": [
    ///        1705312800000
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "totalLiquidityInNative": {
    ///      "description": "DTO.TOKEN.LIQUIDITY_SNAPSHOT.TOTAL_LIQUIDITY_IN_NATIVE",
    ///      "examples": [
    ///        "10000.246"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "totalLiquidityInUsd": {
    ///      "description": "DTO.TOKEN.LIQUIDITY_SNAPSHOT.TOTAL_LIQUIDITY_IN_USD",
    ///      "examples": [
    ///        "2000000.90"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct TokenLiquiditySnapshotDto {
        ///DTO.TOKEN.LIQUIDITY_SNAPSHOT.CALCULATED_AT
        #[serde(rename = "calculatedAt")]
        pub calculated_at: i64,
        ///DTO.TOKEN.LIQUIDITY_SNAPSHOT.MAX_LIQUIDITY_IN_NATIVE
        #[serde(rename = "maxLiquidityInNative")]
        pub max_liquidity_in_native: ::std::string::String,
        ///DTO.TOKEN.LIQUIDITY_SNAPSHOT.MAX_LIQUIDITY_IN_USD
        #[serde(rename = "maxLiquidityInUsd")]
        pub max_liquidity_in_usd: ::std::string::String,
        ///DTO.TOKEN.LIQUIDITY_SNAPSHOT.MAX_LIQUIDITY_POOL_ADDRESS
        #[serde(rename = "maxLiquidityPoolAddress")]
        pub max_liquidity_pool_address: ::std::string::String,
        ///DTO.TOKEN.LIQUIDITY_SNAPSHOT.POOL_COUNT
        #[serde(rename = "poolCount")]
        pub pool_count: i64,
        ///DTO.TOKEN.LIQUIDITY_SNAPSHOT.PRICE_NATIVE
        #[serde(rename = "priceNative")]
        pub price_native: ::std::string::String,
        ///DTO.TOKEN.LIQUIDITY_SNAPSHOT.PRICE_USD
        #[serde(rename = "priceUsd")]
        pub price_usd: ::std::string::String,
        ///DTO.TOKEN.LIQUIDITY_SNAPSHOT.SNAPSHOT_TIME
        #[serde(rename = "snapshotTime")]
        pub snapshot_time: i64,
        ///DTO.TOKEN.LIQUIDITY_SNAPSHOT.TOTAL_LIQUIDITY_IN_NATIVE
        #[serde(rename = "totalLiquidityInNative")]
        pub total_liquidity_in_native: ::std::string::String,
        ///DTO.TOKEN.LIQUIDITY_SNAPSHOT.TOTAL_LIQUIDITY_IN_USD
        #[serde(rename = "totalLiquidityInUsd")]
        pub total_liquidity_in_usd: ::std::string::String,
    }
    impl ::std::convert::From<&TokenLiquiditySnapshotDto> for TokenLiquiditySnapshotDto {
        fn from(value: &TokenLiquiditySnapshotDto) -> Self {
            value.clone()
        }
    }
    impl TokenLiquiditySnapshotDto {
        pub fn builder() -> builder::TokenLiquiditySnapshotDto {
            Default::default()
        }
    }
    ///`TokenLiquiditySnapshotPage`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "data",
    ///    "hasNext",
    ///    "hasPrev"
    ///  ],
    ///  "properties": {
    ///    "data": {
    ///      "description": "DTO.PAGE.DATA",
    ///      "type": "array",
    ///      "items": {
    ///        "$ref": "#/components/schemas/TokenLiquiditySnapshotDTO"
    ///      }
    ///    },
    ///    "endCursor": {
    ///      "description": "DTO.PAGE.END_CURSOR",
    ///      "type": "string"
    ///    },
    ///    "hasNext": {
    ///      "description": "DTO.PAGE.HAS_NEXT",
    ///      "default": false,
    ///      "type": "boolean"
    ///    },
    ///    "hasPrev": {
    ///      "description": "DTO.PAGE.HAS_PREV",
    ///      "default": false,
    ///      "type": "boolean"
    ///    },
    ///    "startCursor": {
    ///      "description": "DTO.PAGE.START_CURSOR",
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct TokenLiquiditySnapshotPage {
        ///DTO.PAGE.DATA
        pub data: ::std::vec::Vec<TokenLiquiditySnapshotDto>,
        ///DTO.PAGE.END_CURSOR
        #[serde(
            rename = "endCursor",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub end_cursor: ::std::option::Option<::std::string::String>,
        ///DTO.PAGE.HAS_NEXT
        #[serde(rename = "hasNext")]
        pub has_next: bool,
        ///DTO.PAGE.HAS_PREV
        #[serde(rename = "hasPrev")]
        pub has_prev: bool,
        ///DTO.PAGE.START_CURSOR
        #[serde(
            rename = "startCursor",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub start_cursor: ::std::option::Option<::std::string::String>,
    }
    impl ::std::convert::From<&TokenLiquiditySnapshotPage>
    for TokenLiquiditySnapshotPage {
        fn from(value: &TokenLiquiditySnapshotPage) -> Self {
            value.clone()
        }
    }
    impl TokenLiquiditySnapshotPage {
        pub fn builder() -> builder::TokenLiquiditySnapshotPage {
            Default::default()
        }
    }
    ///`TokenListPage`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "data"
    ///  ],
    ///  "properties": {
    ///    "data": {
    ///      "description": "DTO.TOKEN.PAGE.DATA",
    ///      "type": "array",
    ///      "items": {
    ///        "$ref": "#/components/schemas/Token"
    ///      }
    ///    },
    ///    "endCursor": {
    ///      "description": "DTO.PAGE.END_CURSOR",
    ///      "type": "string"
    ///    },
    ///    "hasNext": {
    ///      "description": "DTO.PAGE.HAS_NEXT",
    ///      "default": false,
    ///      "type": "boolean"
    ///    },
    ///    "hasPrev": {
    ///      "description": "DTO.PAGE.HAS_PREV",
    ///      "default": false,
    ///      "type": "boolean"
    ///    },
    ///    "startCursor": {
    ///      "description": "DTO.PAGE.START_CURSOR",
    ///      "type": "string"
    ///    },
    ///    "total": {
    ///      "description": "DTO.PAGE.TOTAL",
    ///      "default": 0,
    ///      "type": "integer",
    ///      "format": "int64"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct TokenListPage {
        ///DTO.TOKEN.PAGE.DATA
        pub data: ::std::vec::Vec<Token>,
        ///DTO.PAGE.END_CURSOR
        #[serde(
            rename = "endCursor",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub end_cursor: ::std::option::Option<::std::string::String>,
        ///DTO.PAGE.HAS_NEXT
        #[serde(rename = "hasNext", default)]
        pub has_next: bool,
        ///DTO.PAGE.HAS_PREV
        #[serde(rename = "hasPrev", default)]
        pub has_prev: bool,
        ///DTO.PAGE.START_CURSOR
        #[serde(
            rename = "startCursor",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub start_cursor: ::std::option::Option<::std::string::String>,
        ///DTO.PAGE.TOTAL
        #[serde(default)]
        pub total: i64,
    }
    impl ::std::convert::From<&TokenListPage> for TokenListPage {
        fn from(value: &TokenListPage) -> Self {
            value.clone()
        }
    }
    impl TokenListPage {
        pub fn builder() -> builder::TokenListPage {
            Default::default()
        }
    }
    ///`TokenMarketData`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "holders",
    ///    "marketCapInUsd",
    ///    "priceInUsd",
    ///    "totalSupply",
    ///    "totalTvlInSol",
    ///    "totalTvlInUsd"
    ///  ],
    ///  "properties": {
    ///    "bluechipHoldingsRatio": {
    ///      "description": "DTO.TOKEN.MARKET_CAP.BLUECHIP_HOLDINGS_RATIO",
    ///      "examples": [
    ///        "0.05"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "bluechipTotalHolders": {
    ///      "description": "DTO.TOKEN.MARKET_CAP.BLUECHIP_TOTAL_HOLDERS",
    ///      "examples": [
    ///        "10"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "bluechipTotalHoldings": {
    ///      "description": "DTO.TOKEN.MARKET_CAP.BLUECHIP_TOTAL_HOLDINGS",
    ///      "examples": [
    ///        "50000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "bundleHoldingsRatio": {
    ///      "description": "DTO.TOKEN.MARKET_CAP.BUNDLE_HOLDINGS_RATIO",
    ///      "examples": [
    ///        "0.018"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "bundleTotalHolders": {
    ///      "description": "DTO.TOKEN.MARKET_CAP.BUNDLE_TOTAL_HOLDERS",
    ///      "examples": [
    ///        "12"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "bundleTotalHoldings": {
    ///      "description": "DTO.TOKEN.MARKET_CAP.BUNDLE_TOTAL_HOLDINGS",
    ///      "examples": [
    ///        "18000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "completionRatio": {
    ///      "description": "DTO.TOKEN.MARKET_CAP.COMPLETION_RATIO",
    ///      "examples": [
    ///        "0.1"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "devHoldingsRatio": {
    ///      "description": "DTO.TOKEN.MARKET_CAP.DEV_HOLDINGS_RATIO",
    ///      "examples": [
    ///        "0.005"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "devTotalHolders": {
    ///      "description": "DTO.TOKEN.MARKET_CAP.DEV_TOTAL_HOLDERS",
    ///      "examples": [
    ///        "3"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "devTotalHoldings": {
    ///      "description": "DTO.TOKEN.MARKET_CAP.DEV_TOTAL_HOLDINGS",
    ///      "examples": [
    ///        "5000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "freshHoldingsRatio": {
    ///      "description": "DTO.TOKEN.MARKET_CAP.FRESH_HOLDINGS_RATIO",
    ///      "examples": [
    ///        "0.01"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "freshTotalHolders": {
    ///      "description": "DTO.TOKEN.MARKET_CAP.FRESH_TOTAL_HOLDERS",
    ///      "examples": [
    ///        "30"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "freshTotalHoldings": {
    ///      "description": "DTO.TOKEN.MARKET_CAP.FRESH_TOTAL_HOLDINGS",
    ///      "examples": [
    ///        "10000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "holders": {
    ///      "description": "DTO.TOKEN.MARKET_CAP.HOLDERS",
    ///      "examples": [
    ///        "1000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "insiderHoldingsRatio": {
    ///      "description": "DTO.TOKEN.MARKET_CAP.INSIDER_HOLDINGS_RATIO",
    ///      "examples": [
    ///        "0.02"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "insiderTotalHolders": {
    ///      "description": "DTO.TOKEN.MARKET_CAP.INSIDER_TOTAL_HOLDERS",
    ///      "examples": [
    ///        "5"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "insiderTotalHoldings": {
    ///      "description": "DTO.TOKEN.MARKET_CAP.INSIDER_TOTAL_HOLDINGS",
    ///      "examples": [
    ///        "20000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "kolHoldingsRatio": {
    ///      "description": "DTO.TOKEN.MARKET_CAP.KOL_HOLDINGS_RATIO",
    ///      "examples": [
    ///        "0.03"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "kolTotalHolders": {
    ///      "description": "DTO.TOKEN.MARKET_CAP.KOL_TOTAL_HOLDERS",
    ///      "examples": [
    ///        "20"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "kolTotalHoldings": {
    ///      "description": "DTO.TOKEN.MARKET_CAP.KOL_TOTAL_HOLDINGS",
    ///      "examples": [
    ///        "30000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "marketCapInSol": {
    ///      "description": "DTO.TOKEN.MARKET_CAP.MARKET_CAP_IN_SOL",
    ///      "examples": [
    ///        "100000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "marketCapInUsd": {
    ///      "description": "DTO.TOKEN.MARKET_CAP.MARKET_CAP_IN_USD",
    ///      "examples": [
    ///        "100000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "maxPoolTvlInSol": {
    ///      "description": "DTO.TOKEN.MARKET_CAP.MAX_POOL_TVL_IN_SOL",
    ///      "examples": [
    ///        "0.00000261383847574915906643405542"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "maxPoolTvlInUsd": {
    ///      "description": "DTO.TOKEN.MARKET_CAP.MAX_POOL_TVL_IN_USD",
    ///      "examples": [
    ///        "0.00000261383847574915906643405542"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "priceInSol": {
    ///      "description": "DTO.TOKEN.MARKET_CAP.PRICE_IN_SOL",
    ///      "examples": [
    ///        "0.00000261383847574915906643405542"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "priceInUsd": {
    ///      "description": "DTO.TOKEN.MARKET_CAP.PRICE_IN_USD",
    ///      "examples": [
    ///        "0.00000261383847574915906643405542"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "proHoldingsRatio": {
    ///      "description": "DTO.TOKEN.MARKET_CAP.PRO_HOLDINGS_RATIO",
    ///      "examples": [
    ///        "0.04"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "proTotalHolders": {
    ///      "description": "DTO.TOKEN.MARKET_CAP.PRO_TOTAL_HOLDERS",
    ///      "examples": [
    ///        "25"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "proTotalHoldings": {
    ///      "description": "DTO.TOKEN.MARKET_CAP.PRO_TOTAL_HOLDINGS",
    ///      "examples": [
    ///        "40000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "sandwishHoldingsRatio": {
    ///      "description": "DTO.TOKEN.MARKET_CAP.SANDWISH_HOLDINGS_RATIO",
    ///      "examples": [
    ///        "0.015"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "sandwishTotalHolders": {
    ///      "description": "DTO.TOKEN.MARKET_CAP.SANDWISH_TOTAL_HOLDERS",
    ///      "examples": [
    ///        "8"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "sandwishTotalHoldings": {
    ///      "description": "DTO.TOKEN.MARKET_CAP.SANDWISH_TOTAL_HOLDINGS",
    ///      "examples": [
    ///        "15000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "sniperHoldingsRatio": {
    ///      "description": "DTO.TOKEN.MARKET_CAP.SNIPER_HOLDINGS_RATIO",
    ///      "examples": [
    ///        "0.025"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "sniperTotalHolders": {
    ///      "description": "DTO.TOKEN.MARKET_CAP.SNIPER_TOTAL_HOLDERS",
    ///      "examples": [
    ///        "15"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "sniperTotalHoldings": {
    ///      "description": "DTO.TOKEN.MARKET_CAP.SNIPER_TOTAL_HOLDINGS",
    ///      "examples": [
    ///        "25000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "top100HoldingsRatio": {
    ///      "description": "DTO.TOKEN.MARKET_CAP.TOP100_HOLDINGS_RATIO",
    ///      "examples": [
    ///        "0.5"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "top100TotalHoldings": {
    ///      "description": "DTO.TOKEN.MARKET_CAP.TOP100_TOTAL_HOLDINGS",
    ///      "examples": [
    ///        "500000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "top10HoldingsRatio": {
    ///      "description": "DTO.TOKEN.MARKET_CAP.TOP10_HOLDINGS_RATIO",
    ///      "examples": [
    ///        "0.1"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "top10TotalHoldings": {
    ///      "description": "DTO.TOKEN.MARKET_CAP.TOP10_TOTAL_HOLDINGS",
    ///      "examples": [
    ///        "100000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "top50HoldingsRatio": {
    ///      "description": "DTO.TOKEN.MARKET_CAP.TOP50_HOLDINGS_RATIO",
    ///      "examples": [
    ///        "0.3"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "top50TotalHoldings": {
    ///      "description": "DTO.TOKEN.MARKET_CAP.TOP50_TOTAL_HOLDINGS",
    ///      "examples": [
    ///        "300000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "totalSupply": {
    ///      "description": "DTO.TOKEN.MARKET_CAP.TOTAL_SUPPLY",
    ///      "examples": [
    ///        "1000000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "totalTvlInSol": {
    ///      "description": "DTO.TOKEN.MARKET_CAP.TOTAL_TVL_IN_SOL",
    ///      "examples": [
    ///        "0.00000261383847574915906643405542"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "totalTvlInUsd": {
    ///      "description": "DTO.TOKEN.MARKET_CAP.TOTAL_TVL_IN_USD",
    ///      "examples": [
    ///        "0.00000261383847574915906643405542"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct TokenMarketData {
        ///DTO.TOKEN.MARKET_CAP.BLUECHIP_HOLDINGS_RATIO
        #[serde(
            rename = "bluechipHoldingsRatio",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub bluechip_holdings_ratio: ::std::option::Option<::std::string::String>,
        ///DTO.TOKEN.MARKET_CAP.BLUECHIP_TOTAL_HOLDERS
        #[serde(
            rename = "bluechipTotalHolders",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub bluechip_total_holders: ::std::option::Option<::std::string::String>,
        ///DTO.TOKEN.MARKET_CAP.BLUECHIP_TOTAL_HOLDINGS
        #[serde(
            rename = "bluechipTotalHoldings",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub bluechip_total_holdings: ::std::option::Option<::std::string::String>,
        ///DTO.TOKEN.MARKET_CAP.BUNDLE_HOLDINGS_RATIO
        #[serde(
            rename = "bundleHoldingsRatio",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub bundle_holdings_ratio: ::std::option::Option<::std::string::String>,
        ///DTO.TOKEN.MARKET_CAP.BUNDLE_TOTAL_HOLDERS
        #[serde(
            rename = "bundleTotalHolders",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub bundle_total_holders: ::std::option::Option<::std::string::String>,
        ///DTO.TOKEN.MARKET_CAP.BUNDLE_TOTAL_HOLDINGS
        #[serde(
            rename = "bundleTotalHoldings",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub bundle_total_holdings: ::std::option::Option<::std::string::String>,
        ///DTO.TOKEN.MARKET_CAP.COMPLETION_RATIO
        #[serde(
            rename = "completionRatio",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub completion_ratio: ::std::option::Option<::std::string::String>,
        ///DTO.TOKEN.MARKET_CAP.DEV_HOLDINGS_RATIO
        #[serde(
            rename = "devHoldingsRatio",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub dev_holdings_ratio: ::std::option::Option<::std::string::String>,
        ///DTO.TOKEN.MARKET_CAP.DEV_TOTAL_HOLDERS
        #[serde(
            rename = "devTotalHolders",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub dev_total_holders: ::std::option::Option<::std::string::String>,
        ///DTO.TOKEN.MARKET_CAP.DEV_TOTAL_HOLDINGS
        #[serde(
            rename = "devTotalHoldings",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub dev_total_holdings: ::std::option::Option<::std::string::String>,
        ///DTO.TOKEN.MARKET_CAP.FRESH_HOLDINGS_RATIO
        #[serde(
            rename = "freshHoldingsRatio",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub fresh_holdings_ratio: ::std::option::Option<::std::string::String>,
        ///DTO.TOKEN.MARKET_CAP.FRESH_TOTAL_HOLDERS
        #[serde(
            rename = "freshTotalHolders",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub fresh_total_holders: ::std::option::Option<::std::string::String>,
        ///DTO.TOKEN.MARKET_CAP.FRESH_TOTAL_HOLDINGS
        #[serde(
            rename = "freshTotalHoldings",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub fresh_total_holdings: ::std::option::Option<::std::string::String>,
        ///DTO.TOKEN.MARKET_CAP.HOLDERS
        pub holders: ::std::string::String,
        ///DTO.TOKEN.MARKET_CAP.INSIDER_HOLDINGS_RATIO
        #[serde(
            rename = "insiderHoldingsRatio",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub insider_holdings_ratio: ::std::option::Option<::std::string::String>,
        ///DTO.TOKEN.MARKET_CAP.INSIDER_TOTAL_HOLDERS
        #[serde(
            rename = "insiderTotalHolders",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub insider_total_holders: ::std::option::Option<::std::string::String>,
        ///DTO.TOKEN.MARKET_CAP.INSIDER_TOTAL_HOLDINGS
        #[serde(
            rename = "insiderTotalHoldings",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub insider_total_holdings: ::std::option::Option<::std::string::String>,
        ///DTO.TOKEN.MARKET_CAP.KOL_HOLDINGS_RATIO
        #[serde(
            rename = "kolHoldingsRatio",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub kol_holdings_ratio: ::std::option::Option<::std::string::String>,
        ///DTO.TOKEN.MARKET_CAP.KOL_TOTAL_HOLDERS
        #[serde(
            rename = "kolTotalHolders",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub kol_total_holders: ::std::option::Option<::std::string::String>,
        ///DTO.TOKEN.MARKET_CAP.KOL_TOTAL_HOLDINGS
        #[serde(
            rename = "kolTotalHoldings",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub kol_total_holdings: ::std::option::Option<::std::string::String>,
        ///DTO.TOKEN.MARKET_CAP.MARKET_CAP_IN_SOL
        #[serde(
            rename = "marketCapInSol",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub market_cap_in_sol: ::std::option::Option<::std::string::String>,
        ///DTO.TOKEN.MARKET_CAP.MARKET_CAP_IN_USD
        #[serde(rename = "marketCapInUsd")]
        pub market_cap_in_usd: ::std::string::String,
        ///DTO.TOKEN.MARKET_CAP.MAX_POOL_TVL_IN_SOL
        #[serde(
            rename = "maxPoolTvlInSol",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub max_pool_tvl_in_sol: ::std::option::Option<::std::string::String>,
        ///DTO.TOKEN.MARKET_CAP.MAX_POOL_TVL_IN_USD
        #[serde(
            rename = "maxPoolTvlInUsd",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub max_pool_tvl_in_usd: ::std::option::Option<::std::string::String>,
        ///DTO.TOKEN.MARKET_CAP.PRICE_IN_SOL
        #[serde(
            rename = "priceInSol",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub price_in_sol: ::std::option::Option<::std::string::String>,
        ///DTO.TOKEN.MARKET_CAP.PRICE_IN_USD
        #[serde(rename = "priceInUsd")]
        pub price_in_usd: ::std::string::String,
        ///DTO.TOKEN.MARKET_CAP.PRO_HOLDINGS_RATIO
        #[serde(
            rename = "proHoldingsRatio",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub pro_holdings_ratio: ::std::option::Option<::std::string::String>,
        ///DTO.TOKEN.MARKET_CAP.PRO_TOTAL_HOLDERS
        #[serde(
            rename = "proTotalHolders",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub pro_total_holders: ::std::option::Option<::std::string::String>,
        ///DTO.TOKEN.MARKET_CAP.PRO_TOTAL_HOLDINGS
        #[serde(
            rename = "proTotalHoldings",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub pro_total_holdings: ::std::option::Option<::std::string::String>,
        ///DTO.TOKEN.MARKET_CAP.SANDWISH_HOLDINGS_RATIO
        #[serde(
            rename = "sandwishHoldingsRatio",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub sandwish_holdings_ratio: ::std::option::Option<::std::string::String>,
        ///DTO.TOKEN.MARKET_CAP.SANDWISH_TOTAL_HOLDERS
        #[serde(
            rename = "sandwishTotalHolders",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub sandwish_total_holders: ::std::option::Option<::std::string::String>,
        ///DTO.TOKEN.MARKET_CAP.SANDWISH_TOTAL_HOLDINGS
        #[serde(
            rename = "sandwishTotalHoldings",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub sandwish_total_holdings: ::std::option::Option<::std::string::String>,
        ///DTO.TOKEN.MARKET_CAP.SNIPER_HOLDINGS_RATIO
        #[serde(
            rename = "sniperHoldingsRatio",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub sniper_holdings_ratio: ::std::option::Option<::std::string::String>,
        ///DTO.TOKEN.MARKET_CAP.SNIPER_TOTAL_HOLDERS
        #[serde(
            rename = "sniperTotalHolders",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub sniper_total_holders: ::std::option::Option<::std::string::String>,
        ///DTO.TOKEN.MARKET_CAP.SNIPER_TOTAL_HOLDINGS
        #[serde(
            rename = "sniperTotalHoldings",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub sniper_total_holdings: ::std::option::Option<::std::string::String>,
        ///DTO.TOKEN.MARKET_CAP.TOP100_HOLDINGS_RATIO
        #[serde(
            rename = "top100HoldingsRatio",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub top100_holdings_ratio: ::std::option::Option<::std::string::String>,
        ///DTO.TOKEN.MARKET_CAP.TOP100_TOTAL_HOLDINGS
        #[serde(
            rename = "top100TotalHoldings",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub top100_total_holdings: ::std::option::Option<::std::string::String>,
        ///DTO.TOKEN.MARKET_CAP.TOP10_HOLDINGS_RATIO
        #[serde(
            rename = "top10HoldingsRatio",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub top10_holdings_ratio: ::std::option::Option<::std::string::String>,
        ///DTO.TOKEN.MARKET_CAP.TOP10_TOTAL_HOLDINGS
        #[serde(
            rename = "top10TotalHoldings",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub top10_total_holdings: ::std::option::Option<::std::string::String>,
        ///DTO.TOKEN.MARKET_CAP.TOP50_HOLDINGS_RATIO
        #[serde(
            rename = "top50HoldingsRatio",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub top50_holdings_ratio: ::std::option::Option<::std::string::String>,
        ///DTO.TOKEN.MARKET_CAP.TOP50_TOTAL_HOLDINGS
        #[serde(
            rename = "top50TotalHoldings",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub top50_total_holdings: ::std::option::Option<::std::string::String>,
        ///DTO.TOKEN.MARKET_CAP.TOTAL_SUPPLY
        #[serde(rename = "totalSupply")]
        pub total_supply: ::std::string::String,
        ///DTO.TOKEN.MARKET_CAP.TOTAL_TVL_IN_SOL
        #[serde(rename = "totalTvlInSol")]
        pub total_tvl_in_sol: ::std::string::String,
        ///DTO.TOKEN.MARKET_CAP.TOTAL_TVL_IN_USD
        #[serde(rename = "totalTvlInUsd")]
        pub total_tvl_in_usd: ::std::string::String,
    }
    impl ::std::convert::From<&TokenMarketData> for TokenMarketData {
        fn from(value: &TokenMarketData) -> Self {
            value.clone()
        }
    }
    impl TokenMarketData {
        pub fn builder() -> builder::TokenMarketData {
            Default::default()
        }
    }
    ///`TokenMetadata`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "address",
    ///    "chain",
    ///    "decimals",
    ///    "name",
    ///    "symbol"
    ///  ],
    ///  "properties": {
    ///    "address": {
    ///      "description": "DTO.TOKEN.METADATA.ADDRESS",
    ///      "examples": [
    ///        "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "chain": {
    ///      "description": "DTO.TOKEN.METADATA.CHAIN",
    ///      "examples": [
    ///        "solana"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "coingeckoCoinId": {
    ///      "description": "DTO.TOKEN.METADATA.COINGECKO_COIN_ID",
    ///      "examples": [
    ///        "usd-coin"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "decimals": {
    ///      "description": "DTO.TOKEN.METADATA.DECIMALS",
    ///      "examples": [
    ///        9
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "description": {
    ///      "description": "DTO.TOKEN.METADATA.DESCRIPTION",
    ///      "examples": [
    ///        "USDC is a stablecoin pegged to the US dollar"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "devLastTokenCreatedAt": {
    ///      "description": "DTO.TOKEN.METADATA.DEV_LAST_TOKEN_CREATED_AT",
    ///      "examples": [
    ///        "2025-12-03T09:23:34.000Z"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "devTotalTokens": {
    ///      "description": "DTO.TOKEN.METADATA.DEV_TOTAL_TOKENS",
    ///      "examples": [
    ///        "163"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "extra": {
    ///      "description": "DTO.TOKEN.METADATA.EXTRA",
    ///      "allOf": [
    ///        {
    ///          "$ref": "#/components/schemas/TokenExtraDTO"
    ///        }
    ///      ]
    ///    },
    ///    "imageUrl": {
    ///      "description": "DTO.TOKEN.METADATA.IMAGE_URL",
    ///      "examples": [
    ///        "https://raw.githubusercontent.com/solana-labs/token-list/main/assets/mainnet/EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v/logo.png"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "metadataAddress": {
    ///      "description": "DTO.TOKEN.METADATA.METADATA_ADDRESS",
    ///      "examples": [
    ///        "metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "name": {
    ///      "description": "DTO.TOKEN.METADATA.NAME",
    ///      "examples": [
    ///        "USD Coin"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "socialMedias": {
    ///      "description": "DTO.TOKEN.METADATA.SOCIAL_MEDIAS",
    ///      "allOf": [
    ///        {
    ///          "$ref": "#/components/schemas/TokenSocialMediasDTO"
    ///        }
    ///      ]
    ///    },
    ///    "symbol": {
    ///      "description": "DTO.TOKEN.METADATA.SYMBOL",
    ///      "examples": [
    ///        "USDC"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "tokenCreatedAt": {
    ///      "description": "DTO.TOKEN.METADATA.TOKEN_CREATED_AT",
    ///      "examples": [
    ///        1710417600000
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "tokenCreatedBlockHeight": {
    ///      "description": "DTO.TOKEN.METADATA.TOKEN_CREATED_BLOCK_HEIGHT",
    ///      "examples": [
    ///        "220000000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "tokenCreatedSlot": {
    ///      "description": "DTO.TOKEN.METADATA.TOKEN_CREATED_SLOT",
    ///      "examples": [
    ///        "230000000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "tokenCreatedTxSignature": {
    ///      "description": "DTO.TOKEN.METADATA.TOKEN_CREATED_TX_SIGNATURE",
    ///      "examples": [
    ///        "5dJ1BxPiFT7w7aBdkxNy2jopGZnZoLwRwS8e9GkEXrVz..."
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "tokenCreators": {
    ///      "description": "DTO.TOKEN.METADATA.TOKEN_CREATORS",
    ///      "type": "array",
    ///      "items": {
    ///        "$ref": "#/components/schemas/TokenCreatorsDTO"
    ///      }
    ///    },
    ///    "uri": {
    ///      "description": "DTO.TOKEN.METADATA.URI",
    ///      "examples": [
    ///        "https://..."
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct TokenMetadata {
        ///DTO.TOKEN.METADATA.ADDRESS
        pub address: ::std::string::String,
        ///DTO.TOKEN.METADATA.CHAIN
        pub chain: ::std::string::String,
        ///DTO.TOKEN.METADATA.COINGECKO_COIN_ID
        #[serde(
            rename = "coingeckoCoinId",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub coingecko_coin_id: ::std::option::Option<::std::string::String>,
        ///DTO.TOKEN.METADATA.DECIMALS
        pub decimals: i64,
        ///DTO.TOKEN.METADATA.DESCRIPTION
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub description: ::std::option::Option<::std::string::String>,
        ///DTO.TOKEN.METADATA.DEV_LAST_TOKEN_CREATED_AT
        #[serde(
            rename = "devLastTokenCreatedAt",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub dev_last_token_created_at: ::std::option::Option<::std::string::String>,
        ///DTO.TOKEN.METADATA.DEV_TOTAL_TOKENS
        #[serde(
            rename = "devTotalTokens",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub dev_total_tokens: ::std::option::Option<::std::string::String>,
        ///DTO.TOKEN.METADATA.EXTRA
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub extra: ::std::option::Option<TokenExtraDto>,
        ///DTO.TOKEN.METADATA.IMAGE_URL
        #[serde(
            rename = "imageUrl",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub image_url: ::std::option::Option<::std::string::String>,
        ///DTO.TOKEN.METADATA.METADATA_ADDRESS
        #[serde(
            rename = "metadataAddress",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub metadata_address: ::std::option::Option<::std::string::String>,
        ///DTO.TOKEN.METADATA.NAME
        pub name: ::std::string::String,
        ///DTO.TOKEN.METADATA.SOCIAL_MEDIAS
        #[serde(
            rename = "socialMedias",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub social_medias: ::std::option::Option<TokenSocialMediasDto>,
        ///DTO.TOKEN.METADATA.SYMBOL
        pub symbol: ::std::string::String,
        ///DTO.TOKEN.METADATA.TOKEN_CREATED_AT
        #[serde(
            rename = "tokenCreatedAt",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub token_created_at: ::std::option::Option<i64>,
        ///DTO.TOKEN.METADATA.TOKEN_CREATED_BLOCK_HEIGHT
        #[serde(
            rename = "tokenCreatedBlockHeight",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub token_created_block_height: ::std::option::Option<::std::string::String>,
        ///DTO.TOKEN.METADATA.TOKEN_CREATED_SLOT
        #[serde(
            rename = "tokenCreatedSlot",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub token_created_slot: ::std::option::Option<::std::string::String>,
        ///DTO.TOKEN.METADATA.TOKEN_CREATED_TX_SIGNATURE
        #[serde(
            rename = "tokenCreatedTxSignature",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub token_created_tx_signature: ::std::option::Option<::std::string::String>,
        ///DTO.TOKEN.METADATA.TOKEN_CREATORS
        #[serde(
            rename = "tokenCreators",
            default,
            skip_serializing_if = "::std::vec::Vec::is_empty"
        )]
        pub token_creators: ::std::vec::Vec<TokenCreatorsDto>,
        ///DTO.TOKEN.METADATA.URI
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub uri: ::std::option::Option<::std::string::String>,
    }
    impl ::std::convert::From<&TokenMetadata> for TokenMetadata {
        fn from(value: &TokenMetadata) -> Self {
            value.clone()
        }
    }
    impl TokenMetadata {
        pub fn builder() -> builder::TokenMetadata {
            Default::default()
        }
    }
    ///`TokenPage`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "data"
    ///  ],
    ///  "properties": {
    ///    "countsByProtocols": {
    ///      "description": "DTO.TOKEN.PAGE.COUNTS_BY_PROTOCOLS",
    ///      "examples": [
    ///        {
    ///          "sushiswap": 300,
    ///          "uniswap": 500
    ///        }
    ///      ],
    ///      "type": "object"
    ///    },
    ///    "data": {
    ///      "description": "DTO.TOKEN.PAGE.DATA",
    ///      "type": "array",
    ///      "items": {
    ///        "$ref": "#/components/schemas/Token"
    ///      }
    ///    },
    ///    "endCursor": {
    ///      "description": "DTO.PAGE.END_CURSOR",
    ///      "type": "string"
    ///    },
    ///    "hasNext": {
    ///      "description": "DTO.PAGE.HAS_NEXT",
    ///      "default": false,
    ///      "type": "boolean"
    ///    },
    ///    "hasPrev": {
    ///      "description": "DTO.PAGE.HAS_PREV",
    ///      "default": false,
    ///      "type": "boolean"
    ///    },
    ///    "startCursor": {
    ///      "description": "DTO.PAGE.START_CURSOR",
    ///      "type": "string"
    ///    },
    ///    "total": {
    ///      "description": "DTO.PAGE.TOTAL",
    ///      "default": 0,
    ///      "type": "integer",
    ///      "format": "int64"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct TokenPage {
        ///DTO.TOKEN.PAGE.COUNTS_BY_PROTOCOLS
        #[serde(
            rename = "countsByProtocols",
            default,
            skip_serializing_if = "::serde_json::Map::is_empty"
        )]
        pub counts_by_protocols: ::serde_json::Map<
            ::std::string::String,
            ::serde_json::Value,
        >,
        ///DTO.TOKEN.PAGE.DATA
        pub data: ::std::vec::Vec<Token>,
        ///DTO.PAGE.END_CURSOR
        #[serde(
            rename = "endCursor",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub end_cursor: ::std::option::Option<::std::string::String>,
        ///DTO.PAGE.HAS_NEXT
        #[serde(rename = "hasNext", default)]
        pub has_next: bool,
        ///DTO.PAGE.HAS_PREV
        #[serde(rename = "hasPrev", default)]
        pub has_prev: bool,
        ///DTO.PAGE.START_CURSOR
        #[serde(
            rename = "startCursor",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub start_cursor: ::std::option::Option<::std::string::String>,
        ///DTO.PAGE.TOTAL
        #[serde(default)]
        pub total: i64,
    }
    impl ::std::convert::From<&TokenPage> for TokenPage {
        fn from(value: &TokenPage) -> Self {
            value.clone()
        }
    }
    impl TokenPage {
        pub fn builder() -> builder::TokenPage {
            Default::default()
        }
    }
    ///`TokenPriceDto`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "priceInNative",
    ///    "priceInUsd",
    ///    "timestamp",
    ///    "tokenAddress"
    ///  ],
    ///  "properties": {
    ///    "priceInNative": {
    ///      "description": "DTO.TOKEN.PRICE.PRICE_IN_NATIVE",
    ///      "examples": [
    ///        "1000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "priceInUsd": {
    ///      "description": "DTO.TOKEN.PRICE.PRICE_IN_USD",
    ///      "examples": [
    ///        "1000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "timestamp": {
    ///      "description": "DTO.TOKEN.PRICE.TIMESTAMP",
    ///      "examples": [
    ///        1754055151000
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "tokenAddress": {
    ///      "description": "DTO.TOKEN.PRICE.TOKEN_ADDRESS",
    ///      "examples": [
    ///        "6p6xgHyF7AeE6TZkSmFsko444wqoP15icUSqi2jfGiPN"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct TokenPriceDto {
        ///DTO.TOKEN.PRICE.PRICE_IN_NATIVE
        #[serde(rename = "priceInNative")]
        pub price_in_native: ::std::string::String,
        ///DTO.TOKEN.PRICE.PRICE_IN_USD
        #[serde(rename = "priceInUsd")]
        pub price_in_usd: ::std::string::String,
        ///DTO.TOKEN.PRICE.TIMESTAMP
        pub timestamp: i64,
        ///DTO.TOKEN.PRICE.TOKEN_ADDRESS
        #[serde(rename = "tokenAddress")]
        pub token_address: ::std::string::String,
    }
    impl ::std::convert::From<&TokenPriceDto> for TokenPriceDto {
        fn from(value: &TokenPriceDto) -> Self {
            value.clone()
        }
    }
    impl TokenPriceDto {
        pub fn builder() -> builder::TokenPriceDto {
            Default::default()
        }
    }
    ///`TokenPricePage`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "data"
    ///  ],
    ///  "properties": {
    ///    "data": {
    ///      "description": "DTO.TOKEN.PRICE.PAGE.DATA",
    ///      "type": "array",
    ///      "items": {
    ///        "$ref": "#/components/schemas/TokenPriceDTO"
    ///      }
    ///    },
    ///    "endCursor": {
    ///      "description": "DTO.PAGE.END_CURSOR",
    ///      "type": "string"
    ///    },
    ///    "hasNext": {
    ///      "description": "DTO.PAGE.HAS_NEXT",
    ///      "default": false,
    ///      "type": "boolean"
    ///    },
    ///    "hasPrev": {
    ///      "description": "DTO.PAGE.HAS_PREV",
    ///      "default": false,
    ///      "type": "boolean"
    ///    },
    ///    "startCursor": {
    ///      "description": "DTO.PAGE.START_CURSOR",
    ///      "type": "string"
    ///    },
    ///    "total": {
    ///      "description": "DTO.PAGE.TOTAL",
    ///      "default": 0,
    ///      "type": "integer",
    ///      "format": "int64"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct TokenPricePage {
        ///DTO.TOKEN.PRICE.PAGE.DATA
        pub data: ::std::vec::Vec<TokenPriceDto>,
        ///DTO.PAGE.END_CURSOR
        #[serde(
            rename = "endCursor",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub end_cursor: ::std::option::Option<::std::string::String>,
        ///DTO.PAGE.HAS_NEXT
        #[serde(rename = "hasNext", default)]
        pub has_next: bool,
        ///DTO.PAGE.HAS_PREV
        #[serde(rename = "hasPrev", default)]
        pub has_prev: bool,
        ///DTO.PAGE.START_CURSOR
        #[serde(
            rename = "startCursor",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub start_cursor: ::std::option::Option<::std::string::String>,
        ///DTO.PAGE.TOTAL
        #[serde(default)]
        pub total: i64,
    }
    impl ::std::convert::From<&TokenPricePage> for TokenPricePage {
        fn from(value: &TokenPricePage) -> Self {
            value.clone()
        }
    }
    impl TokenPricePage {
        pub fn builder() -> builder::TokenPricePage {
            Default::default()
        }
    }
    ///`TokenSocialMediasDto`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "properties": {
    ///    "bitbucket": {
    ///      "description": "DTO.TOKEN.SOCIAL_MEDIAS.BITBUCKET",
    ///      "examples": [
    ///        "https://bitbucket.org/circle"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "discord": {
    ///      "description": "DTO.TOKEN.SOCIAL_MEDIAS.DISCORD",
    ///      "examples": [
    ///        "https://discord.gg/circle"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "facebook": {
    ///      "description": "DTO.TOKEN.SOCIAL_MEDIAS.FACEBOOK",
    ///      "examples": [
    ///        "https://facebook.com/circle"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "github": {
    ///      "description": "DTO.TOKEN.SOCIAL_MEDIAS.GITHUB",
    ///      "examples": [
    ///        "https://github.com/circle"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "instagram": {
    ///      "description": "DTO.TOKEN.SOCIAL_MEDIAS.INSTAGRAM",
    ///      "examples": [
    ///        "@circle"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "linkedin": {
    ///      "description": "DTO.TOKEN.SOCIAL_MEDIAS.LINKEDIN",
    ///      "examples": [
    ///        "https://linkedin.com/company/circle"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "medium": {
    ///      "description": "DTO.TOKEN.SOCIAL_MEDIAS.MEDIUM",
    ///      "examples": [
    ///        "https://medium.com/@circle"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "reddit": {
    ///      "description": "DTO.TOKEN.SOCIAL_MEDIAS.REDDIT",
    ///      "examples": [
    ///        "https://reddit.com/r/circle"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "telegram": {
    ///      "description": "DTO.TOKEN.SOCIAL_MEDIAS.TELEGRAM",
    ///      "examples": [
    ///        "https://t.me/circle"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "tiktok": {
    ///      "description": "DTO.TOKEN.SOCIAL_MEDIAS.TIKTOK",
    ///      "examples": [
    ///        "@circle"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "twitter": {
    ///      "description": "DTO.TOKEN.SOCIAL_MEDIAS.TWITTER",
    ///      "examples": [
    ///        "@circle"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "website": {
    ///      "description": "DTO.TOKEN.SOCIAL_MEDIAS.WEBSITE",
    ///      "examples": [
    ///        "https://www.circle.com"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "youtube": {
    ///      "description": "DTO.TOKEN.SOCIAL_MEDIAS.YOUTUBE",
    ///      "examples": [
    ///        "https://youtube.com/@circle"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct TokenSocialMediasDto {
        ///DTO.TOKEN.SOCIAL_MEDIAS.BITBUCKET
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub bitbucket: ::std::option::Option<::std::string::String>,
        ///DTO.TOKEN.SOCIAL_MEDIAS.DISCORD
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub discord: ::std::option::Option<::std::string::String>,
        ///DTO.TOKEN.SOCIAL_MEDIAS.FACEBOOK
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub facebook: ::std::option::Option<::std::string::String>,
        ///DTO.TOKEN.SOCIAL_MEDIAS.GITHUB
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub github: ::std::option::Option<::std::string::String>,
        ///DTO.TOKEN.SOCIAL_MEDIAS.INSTAGRAM
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub instagram: ::std::option::Option<::std::string::String>,
        ///DTO.TOKEN.SOCIAL_MEDIAS.LINKEDIN
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub linkedin: ::std::option::Option<::std::string::String>,
        ///DTO.TOKEN.SOCIAL_MEDIAS.MEDIUM
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub medium: ::std::option::Option<::std::string::String>,
        ///DTO.TOKEN.SOCIAL_MEDIAS.REDDIT
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub reddit: ::std::option::Option<::std::string::String>,
        ///DTO.TOKEN.SOCIAL_MEDIAS.TELEGRAM
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub telegram: ::std::option::Option<::std::string::String>,
        ///DTO.TOKEN.SOCIAL_MEDIAS.TIKTOK
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub tiktok: ::std::option::Option<::std::string::String>,
        ///DTO.TOKEN.SOCIAL_MEDIAS.TWITTER
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub twitter: ::std::option::Option<::std::string::String>,
        ///DTO.TOKEN.SOCIAL_MEDIAS.WEBSITE
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub website: ::std::option::Option<::std::string::String>,
        ///DTO.TOKEN.SOCIAL_MEDIAS.YOUTUBE
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub youtube: ::std::option::Option<::std::string::String>,
    }
    impl ::std::convert::From<&TokenSocialMediasDto> for TokenSocialMediasDto {
        fn from(value: &TokenSocialMediasDto) -> Self {
            value.clone()
        }
    }
    impl ::std::default::Default for TokenSocialMediasDto {
        fn default() -> Self {
            Self {
                bitbucket: Default::default(),
                discord: Default::default(),
                facebook: Default::default(),
                github: Default::default(),
                instagram: Default::default(),
                linkedin: Default::default(),
                medium: Default::default(),
                reddit: Default::default(),
                telegram: Default::default(),
                tiktok: Default::default(),
                twitter: Default::default(),
                website: Default::default(),
                youtube: Default::default(),
            }
        }
    }
    impl TokenSocialMediasDto {
        pub fn builder() -> builder::TokenSocialMediasDto {
            Default::default()
        }
    }
    ///`TokenStat`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "address",
    ///    "periods"
    ///  ],
    ///  "properties": {
    ///    "address": {
    ///      "description": "DTO.TOKEN.STAT.ADDRESS",
    ///      "examples": [
    ///        "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "periods": {
    ///      "description": "DTO.TOKEN.TRADE_STAT.PERIODS",
    ///      "examples": [
    ///        {
    ///          "1h": {
    ///            "averagePriceInNative": "0.00005100",
    ///            "averagePriceInUsd": "0.15300000",
    ///            "buySellRatio": "1.5510",
    ///            "buyVolume": "15000000.12345678",
    ///            "buyVolumeInNative": "750.50",
    ///            "buyVolumeInUsd": "45000.00",
    ///            "buyers": "320",
    ///            "buys": "1520",
    ///            "closeInNative": "0.00005200",
    ///            "closeInUsd": "0.15600000",
    ///            "currentLiquidityInUsd": "250000.00",
    ///            "dappProgramCount": "8",
    ///            "highInNative": "0.00005300",
    ///            "highInUsd": "0.15900000",
    ///            "liquidityChangeRatio": "0.0417",
    ///            "lowInNative": "0.00005000",
    ///            "lowInUsd": "0.15000000",
    ///            "openInNative": "0.00005000",
    ///            "openInUsd": "0.15000000",
    ///            "poolCount": "12",
    ///            "prevBuyVolume": "14000000.00",
    ///            "prevBuyVolumeInNative": "700.00",
    ///            "prevBuyVolumeInUsd": "42000.00",
    ///            "prevBuyers": "300",
    ///            "prevBuys": "1400",
    ///            "prevCloseInNative": "0.00005100",
    ///            "prevCloseInUsd": "0.15100000",
    ///            "prevDappProgramCount": "7",
    ///            "prevHighInNative": "0.00005100",
    ///            "prevHighInUsd": "0.15200000",
    ///            "prevLiquidityInUsd": "240000.00",
    ///            "prevLowInNative": "0.00004800",
    ///            "prevLowInUsd": "0.14500000",
    ///            "prevOpenInNative": "0.00004900",
    ///            "prevOpenInUsd": "0.14800000",
    ///            "prevPoolCount": "10",
    ///            "prevSellVolume": "11000000.00",
    ///            "prevSellVolumeInNative": "550.00",
    ///            "prevSellVolumeInUsd": "33000.00",
    ///            "prevSellers": "200",
    ///            "prevSells": "900",
    ///            "prevTrades": "2300",
    ///            "priceChangeRatioInUsd": "0.04000000",
    ///            "sellVolume": "12000000.98765432",
    ///            "sellVolumeInNative": "600.40",
    ///            "sellVolumeInUsd": "36000.00",
    ///            "sellers": "210",
    ///            "sells": "980",
    ///            "totalVolumeInNative": "1350.90",
    ///            "totalVolumeInUsd": "81000.00",
    ///            "traders": "530",
    ///            "trades": "2500",
    ///            "updatedAt": "2026-02-09T08:05:12.345Z",
    ///            "volumeChangeRatio": "0.08"
    ///          }
    ///        }
    ///      ],
    ///      "type": "object",
    ///      "additionalProperties": {
    ///        "$ref": "#/components/schemas/TokenTradeStatPeriod"
    ///      }
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct TokenStat {
        ///DTO.TOKEN.STAT.ADDRESS
        pub address: ::std::string::String,
        ///DTO.TOKEN.TRADE_STAT.PERIODS
        pub periods: ::std::collections::HashMap<
            ::std::string::String,
            TokenTradeStatPeriod,
        >,
    }
    impl ::std::convert::From<&TokenStat> for TokenStat {
        fn from(value: &TokenStat) -> Self {
            value.clone()
        }
    }
    impl TokenStat {
        pub fn builder() -> builder::TokenStat {
            Default::default()
        }
    }
    ///`TokenTradeStatPeriod`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "averagePriceInNative",
    ///    "averagePriceInUsd",
    ///    "buyVolume",
    ///    "buyVolumeInNative",
    ///    "buyVolumeInUsd",
    ///    "buyers",
    ///    "buys",
    ///    "closeInNative",
    ///    "closeInUsd",
    ///    "currentLiquidityInUsd",
    ///    "dappProgramCount",
    ///    "highInNative",
    ///    "highInUsd",
    ///    "lowInNative",
    ///    "lowInUsd",
    ///    "openInNative",
    ///    "openInUsd",
    ///    "poolCount",
    ///    "prevBuyVolume",
    ///    "prevBuyVolumeInNative",
    ///    "prevBuyVolumeInUsd",
    ///    "prevBuyers",
    ///    "prevBuys",
    ///    "prevCloseInNative",
    ///    "prevCloseInUsd",
    ///    "prevDappProgramCount",
    ///    "prevHighInNative",
    ///    "prevHighInUsd",
    ///    "prevLiquidityInUsd",
    ///    "prevLowInNative",
    ///    "prevLowInUsd",
    ///    "prevOpenInNative",
    ///    "prevOpenInUsd",
    ///    "prevPoolCount",
    ///    "prevSellVolume",
    ///    "prevSellVolumeInNative",
    ///    "prevSellVolumeInUsd",
    ///    "prevSellers",
    ///    "prevSells",
    ///    "prevTrades",
    ///    "priceChangeRatioInUsd",
    ///    "sellVolume",
    ///    "sellVolumeInNative",
    ///    "sellVolumeInUsd",
    ///    "sellers",
    ///    "sells",
    ///    "totalVolumeInNative",
    ///    "totalVolumeInUsd",
    ///    "traders",
    ///    "trades"
    ///  ],
    ///  "properties": {
    ///    "averagePriceInNative": {
    ///      "description": "DTO.TOKEN.TRADE_STAT.PERIOD.AVERAGE_PRICE_IN_NATIVE",
    ///      "examples": [
    ///        "0.00005100"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "averagePriceInUsd": {
    ///      "description": "DTO.TOKEN.TRADE_STAT.PERIOD.AVERAGE_PRICE_IN_USD",
    ///      "examples": [
    ///        "0.15300000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "buySellRatio": {
    ///      "description": "DTO.TOKEN.TRADE_STAT.PERIOD.BUY_SELL_RATIO",
    ///      "examples": [
    ///        "1.5510"
    ///      ],
    ///      "type": "object"
    ///    },
    ///    "buyVolume": {
    ///      "description": "DTO.TOKEN.TRADE_STAT.PERIOD.BUY_VOLUME",
    ///      "examples": [
    ///        "15000000.12345678"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "buyVolumeInNative": {
    ///      "description": "DTO.TOKEN.TRADE_STAT.PERIOD.BUY_VOLUME_IN_NATIVE",
    ///      "examples": [
    ///        "750.50"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "buyVolumeInUsd": {
    ///      "description": "DTO.TOKEN.TRADE_STAT.PERIOD.BUY_VOLUME_IN_USD",
    ///      "examples": [
    ///        "45000.00"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "buyers": {
    ///      "description": "DTO.TOKEN.TRADE_STAT.PERIOD.BUYERS",
    ///      "examples": [
    ///        "320"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "buys": {
    ///      "description": "DTO.TOKEN.TRADE_STAT.PERIOD.BUYS",
    ///      "examples": [
    ///        "1520"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "closeInNative": {
    ///      "description": "DTO.TOKEN.TRADE_STAT.PERIOD.CLOSE_IN_NATIVE",
    ///      "examples": [
    ///        "0.00005200"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "closeInUsd": {
    ///      "description": "DTO.TOKEN.TRADE_STAT.PERIOD.CLOSE_IN_USD",
    ///      "examples": [
    ///        "0.15600000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "currentLiquidityInUsd": {
    ///      "description": "DTO.TOKEN.TRADE_STAT.PERIOD.CURRENT_LIQUIDITY_IN_USD",
    ///      "examples": [
    ///        "250000.00"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "dappProgramCount": {
    ///      "description": "DTO.TOKEN.TRADE_STAT.PERIOD.DAPP_PROGRAM_COUNT",
    ///      "examples": [
    ///        "8"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "highInNative": {
    ///      "description": "DTO.TOKEN.TRADE_STAT.PERIOD.HIGH_IN_NATIVE",
    ///      "examples": [
    ///        "0.00005300"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "highInUsd": {
    ///      "description": "DTO.TOKEN.TRADE_STAT.PERIOD.HIGH_IN_USD",
    ///      "examples": [
    ///        "0.15900000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "liquidityChangeRatio": {
    ///      "description": "DTO.TOKEN.TRADE_STAT.PERIOD.LIQUIDITY_CHANGE_RATIO",
    ///      "examples": [
    ///        "0.0417"
    ///      ],
    ///      "type": "object"
    ///    },
    ///    "lowInNative": {
    ///      "description": "DTO.TOKEN.TRADE_STAT.PERIOD.LOW_IN_NATIVE",
    ///      "examples": [
    ///        "0.00005000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "lowInUsd": {
    ///      "description": "DTO.TOKEN.TRADE_STAT.PERIOD.LOW_IN_USD",
    ///      "examples": [
    ///        "0.15000000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "openInNative": {
    ///      "description": "DTO.TOKEN.TRADE_STAT.PERIOD.OPEN_IN_NATIVE",
    ///      "examples": [
    ///        "0.00005000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "openInUsd": {
    ///      "description": "DTO.TOKEN.TRADE_STAT.PERIOD.OPEN_IN_USD",
    ///      "examples": [
    ///        "0.15000000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "poolCount": {
    ///      "description": "DTO.TOKEN.TRADE_STAT.PERIOD.POOL_COUNT",
    ///      "examples": [
    ///        "12"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "prevBuyVolume": {
    ///      "description": "DTO.TOKEN.TRADE_STAT.PERIOD.PREV_BUY_VOLUME",
    ///      "examples": [
    ///        "14000000.00"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "prevBuyVolumeInNative": {
    ///      "description": "DTO.TOKEN.TRADE_STAT.PERIOD.PREV_BUY_VOLUME_IN_NATIVE",
    ///      "examples": [
    ///        "700.00"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "prevBuyVolumeInUsd": {
    ///      "description": "DTO.TOKEN.TRADE_STAT.PERIOD.PREV_BUY_VOLUME_IN_USD",
    ///      "examples": [
    ///        "42000.00"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "prevBuyers": {
    ///      "description": "DTO.TOKEN.TRADE_STAT.PERIOD.PREV_BUYERS",
    ///      "examples": [
    ///        "300"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "prevBuys": {
    ///      "description": "DTO.TOKEN.TRADE_STAT.PERIOD.PREV_BUYS",
    ///      "examples": [
    ///        "1400"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "prevCloseInNative": {
    ///      "description": "DTO.TOKEN.TRADE_STAT.PERIOD.PREV_CLOSE_IN_NATIVE",
    ///      "examples": [
    ///        "0.00005100"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "prevCloseInUsd": {
    ///      "description": "DTO.TOKEN.TRADE_STAT.PERIOD.PREV_CLOSE_IN_USD",
    ///      "examples": [
    ///        "0.15100000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "prevDappProgramCount": {
    ///      "description": "DTO.TOKEN.TRADE_STAT.PERIOD.PREV_DAPP_PROGRAM_COUNT",
    ///      "examples": [
    ///        "7"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "prevHighInNative": {
    ///      "description": "DTO.TOKEN.TRADE_STAT.PERIOD.PREV_HIGH_IN_NATIVE",
    ///      "examples": [
    ///        "0.00005100"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "prevHighInUsd": {
    ///      "description": "DTO.TOKEN.TRADE_STAT.PERIOD.PREV_HIGH_IN_USD",
    ///      "examples": [
    ///        "0.15200000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "prevLiquidityInUsd": {
    ///      "description": "DTO.TOKEN.TRADE_STAT.PERIOD.PREV_LIQUIDITY_IN_USD",
    ///      "examples": [
    ///        "240000.00"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "prevLowInNative": {
    ///      "description": "DTO.TOKEN.TRADE_STAT.PERIOD.PREV_LOW_IN_NATIVE",
    ///      "examples": [
    ///        "0.00004800"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "prevLowInUsd": {
    ///      "description": "DTO.TOKEN.TRADE_STAT.PERIOD.PREV_LOW_IN_USD",
    ///      "examples": [
    ///        "0.14500000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "prevOpenInNative": {
    ///      "description": "DTO.TOKEN.TRADE_STAT.PERIOD.PREV_OPEN_IN_NATIVE",
    ///      "examples": [
    ///        "0.00004900"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "prevOpenInUsd": {
    ///      "description": "DTO.TOKEN.TRADE_STAT.PERIOD.PREV_OPEN_IN_USD",
    ///      "examples": [
    ///        "0.14800000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "prevPoolCount": {
    ///      "description": "DTO.TOKEN.TRADE_STAT.PERIOD.PREV_POOL_COUNT",
    ///      "examples": [
    ///        "10"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "prevSellVolume": {
    ///      "description": "DTO.TOKEN.TRADE_STAT.PERIOD.PREV_SELL_VOLUME",
    ///      "examples": [
    ///        "11000000.00"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "prevSellVolumeInNative": {
    ///      "description": "DTO.TOKEN.TRADE_STAT.PERIOD.PREV_SELL_VOLUME_IN_NATIVE",
    ///      "examples": [
    ///        "550.00"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "prevSellVolumeInUsd": {
    ///      "description": "DTO.TOKEN.TRADE_STAT.PERIOD.PREV_SELL_VOLUME_IN_USD",
    ///      "examples": [
    ///        "33000.00"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "prevSellers": {
    ///      "description": "DTO.TOKEN.TRADE_STAT.PERIOD.PREV_SELLERS",
    ///      "examples": [
    ///        "200"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "prevSells": {
    ///      "description": "DTO.TOKEN.TRADE_STAT.PERIOD.PREV_SELLS",
    ///      "examples": [
    ///        "900"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "prevTrades": {
    ///      "description": "DTO.TOKEN.TRADE_STAT.PERIOD.PREV_TRADES",
    ///      "examples": [
    ///        "2300"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "priceChangeRatioInUsd": {
    ///      "description": "DTO.TOKEN.TRADE_STAT.PERIOD.PRICE_CHANGE_RATIO_IN_USD",
    ///      "examples": [
    ///        "0.04000000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "sellVolume": {
    ///      "description": "DTO.TOKEN.TRADE_STAT.PERIOD.SELL_VOLUME",
    ///      "examples": [
    ///        "12000000.98765432"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "sellVolumeInNative": {
    ///      "description": "DTO.TOKEN.TRADE_STAT.PERIOD.SELL_VOLUME_IN_NATIVE",
    ///      "examples": [
    ///        "600.40"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "sellVolumeInUsd": {
    ///      "description": "DTO.TOKEN.TRADE_STAT.PERIOD.SELL_VOLUME_IN_USD",
    ///      "examples": [
    ///        "36000.00"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "sellers": {
    ///      "description": "DTO.TOKEN.TRADE_STAT.PERIOD.SELLERS",
    ///      "examples": [
    ///        "210"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "sells": {
    ///      "description": "DTO.TOKEN.TRADE_STAT.PERIOD.SELLS",
    ///      "examples": [
    ///        "980"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "totalVolumeInNative": {
    ///      "description": "DTO.TOKEN.TRADE_STAT.PERIOD.TOTAL_VOLUME_IN_NATIVE",
    ///      "examples": [
    ///        "1350.90"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "totalVolumeInUsd": {
    ///      "description": "DTO.TOKEN.TRADE_STAT.PERIOD.TOTAL_VOLUME_IN_USD",
    ///      "examples": [
    ///        "81000.00"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "traders": {
    ///      "description": "DTO.TOKEN.TRADE_STAT.PERIOD.TRADERS",
    ///      "examples": [
    ///        "530"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "trades": {
    ///      "description": "DTO.TOKEN.TRADE_STAT.PERIOD.TRADES",
    ///      "examples": [
    ///        "2500"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "updatedAt": {
    ///      "description": "DTO.TOKEN.TRADE_STAT.PERIOD.UPDATED_AT",
    ///      "examples": [
    ///        "2026-02-09T08:05:12.345Z"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "volumeChangeRatio": {
    ///      "description": "DTO.TOKEN.TRADE_STAT.PERIOD.VOLUME_CHANGE_RATIO",
    ///      "examples": [
    ///        "0.25"
    ///      ],
    ///      "type": "object"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct TokenTradeStatPeriod {
        ///DTO.TOKEN.TRADE_STAT.PERIOD.AVERAGE_PRICE_IN_NATIVE
        #[serde(rename = "averagePriceInNative")]
        pub average_price_in_native: ::std::string::String,
        ///DTO.TOKEN.TRADE_STAT.PERIOD.AVERAGE_PRICE_IN_USD
        #[serde(rename = "averagePriceInUsd")]
        pub average_price_in_usd: ::std::string::String,
        ///DTO.TOKEN.TRADE_STAT.PERIOD.BUY_SELL_RATIO
        #[serde(
            rename = "buySellRatio",
            default,
            skip_serializing_if = "::serde_json::Map::is_empty"
        )]
        pub buy_sell_ratio: ::serde_json::Map<
            ::std::string::String,
            ::serde_json::Value,
        >,
        ///DTO.TOKEN.TRADE_STAT.PERIOD.BUY_VOLUME
        #[serde(rename = "buyVolume")]
        pub buy_volume: ::std::string::String,
        ///DTO.TOKEN.TRADE_STAT.PERIOD.BUY_VOLUME_IN_NATIVE
        #[serde(rename = "buyVolumeInNative")]
        pub buy_volume_in_native: ::std::string::String,
        ///DTO.TOKEN.TRADE_STAT.PERIOD.BUY_VOLUME_IN_USD
        #[serde(rename = "buyVolumeInUsd")]
        pub buy_volume_in_usd: ::std::string::String,
        ///DTO.TOKEN.TRADE_STAT.PERIOD.BUYERS
        pub buyers: ::std::string::String,
        ///DTO.TOKEN.TRADE_STAT.PERIOD.BUYS
        pub buys: ::std::string::String,
        ///DTO.TOKEN.TRADE_STAT.PERIOD.CLOSE_IN_NATIVE
        #[serde(rename = "closeInNative")]
        pub close_in_native: ::std::string::String,
        ///DTO.TOKEN.TRADE_STAT.PERIOD.CLOSE_IN_USD
        #[serde(rename = "closeInUsd")]
        pub close_in_usd: ::std::string::String,
        ///DTO.TOKEN.TRADE_STAT.PERIOD.CURRENT_LIQUIDITY_IN_USD
        #[serde(rename = "currentLiquidityInUsd")]
        pub current_liquidity_in_usd: ::std::string::String,
        ///DTO.TOKEN.TRADE_STAT.PERIOD.DAPP_PROGRAM_COUNT
        #[serde(rename = "dappProgramCount")]
        pub dapp_program_count: ::std::string::String,
        ///DTO.TOKEN.TRADE_STAT.PERIOD.HIGH_IN_NATIVE
        #[serde(rename = "highInNative")]
        pub high_in_native: ::std::string::String,
        ///DTO.TOKEN.TRADE_STAT.PERIOD.HIGH_IN_USD
        #[serde(rename = "highInUsd")]
        pub high_in_usd: ::std::string::String,
        ///DTO.TOKEN.TRADE_STAT.PERIOD.LIQUIDITY_CHANGE_RATIO
        #[serde(
            rename = "liquidityChangeRatio",
            default,
            skip_serializing_if = "::serde_json::Map::is_empty"
        )]
        pub liquidity_change_ratio: ::serde_json::Map<
            ::std::string::String,
            ::serde_json::Value,
        >,
        ///DTO.TOKEN.TRADE_STAT.PERIOD.LOW_IN_NATIVE
        #[serde(rename = "lowInNative")]
        pub low_in_native: ::std::string::String,
        ///DTO.TOKEN.TRADE_STAT.PERIOD.LOW_IN_USD
        #[serde(rename = "lowInUsd")]
        pub low_in_usd: ::std::string::String,
        ///DTO.TOKEN.TRADE_STAT.PERIOD.OPEN_IN_NATIVE
        #[serde(rename = "openInNative")]
        pub open_in_native: ::std::string::String,
        ///DTO.TOKEN.TRADE_STAT.PERIOD.OPEN_IN_USD
        #[serde(rename = "openInUsd")]
        pub open_in_usd: ::std::string::String,
        ///DTO.TOKEN.TRADE_STAT.PERIOD.POOL_COUNT
        #[serde(rename = "poolCount")]
        pub pool_count: ::std::string::String,
        ///DTO.TOKEN.TRADE_STAT.PERIOD.PREV_BUY_VOLUME
        #[serde(rename = "prevBuyVolume")]
        pub prev_buy_volume: ::std::string::String,
        ///DTO.TOKEN.TRADE_STAT.PERIOD.PREV_BUY_VOLUME_IN_NATIVE
        #[serde(rename = "prevBuyVolumeInNative")]
        pub prev_buy_volume_in_native: ::std::string::String,
        ///DTO.TOKEN.TRADE_STAT.PERIOD.PREV_BUY_VOLUME_IN_USD
        #[serde(rename = "prevBuyVolumeInUsd")]
        pub prev_buy_volume_in_usd: ::std::string::String,
        ///DTO.TOKEN.TRADE_STAT.PERIOD.PREV_BUYERS
        #[serde(rename = "prevBuyers")]
        pub prev_buyers: ::std::string::String,
        ///DTO.TOKEN.TRADE_STAT.PERIOD.PREV_BUYS
        #[serde(rename = "prevBuys")]
        pub prev_buys: ::std::string::String,
        ///DTO.TOKEN.TRADE_STAT.PERIOD.PREV_CLOSE_IN_NATIVE
        #[serde(rename = "prevCloseInNative")]
        pub prev_close_in_native: ::std::string::String,
        ///DTO.TOKEN.TRADE_STAT.PERIOD.PREV_CLOSE_IN_USD
        #[serde(rename = "prevCloseInUsd")]
        pub prev_close_in_usd: ::std::string::String,
        ///DTO.TOKEN.TRADE_STAT.PERIOD.PREV_DAPP_PROGRAM_COUNT
        #[serde(rename = "prevDappProgramCount")]
        pub prev_dapp_program_count: ::std::string::String,
        ///DTO.TOKEN.TRADE_STAT.PERIOD.PREV_HIGH_IN_NATIVE
        #[serde(rename = "prevHighInNative")]
        pub prev_high_in_native: ::std::string::String,
        ///DTO.TOKEN.TRADE_STAT.PERIOD.PREV_HIGH_IN_USD
        #[serde(rename = "prevHighInUsd")]
        pub prev_high_in_usd: ::std::string::String,
        ///DTO.TOKEN.TRADE_STAT.PERIOD.PREV_LIQUIDITY_IN_USD
        #[serde(rename = "prevLiquidityInUsd")]
        pub prev_liquidity_in_usd: ::std::string::String,
        ///DTO.TOKEN.TRADE_STAT.PERIOD.PREV_LOW_IN_NATIVE
        #[serde(rename = "prevLowInNative")]
        pub prev_low_in_native: ::std::string::String,
        ///DTO.TOKEN.TRADE_STAT.PERIOD.PREV_LOW_IN_USD
        #[serde(rename = "prevLowInUsd")]
        pub prev_low_in_usd: ::std::string::String,
        ///DTO.TOKEN.TRADE_STAT.PERIOD.PREV_OPEN_IN_NATIVE
        #[serde(rename = "prevOpenInNative")]
        pub prev_open_in_native: ::std::string::String,
        ///DTO.TOKEN.TRADE_STAT.PERIOD.PREV_OPEN_IN_USD
        #[serde(rename = "prevOpenInUsd")]
        pub prev_open_in_usd: ::std::string::String,
        ///DTO.TOKEN.TRADE_STAT.PERIOD.PREV_POOL_COUNT
        #[serde(rename = "prevPoolCount")]
        pub prev_pool_count: ::std::string::String,
        ///DTO.TOKEN.TRADE_STAT.PERIOD.PREV_SELL_VOLUME
        #[serde(rename = "prevSellVolume")]
        pub prev_sell_volume: ::std::string::String,
        ///DTO.TOKEN.TRADE_STAT.PERIOD.PREV_SELL_VOLUME_IN_NATIVE
        #[serde(rename = "prevSellVolumeInNative")]
        pub prev_sell_volume_in_native: ::std::string::String,
        ///DTO.TOKEN.TRADE_STAT.PERIOD.PREV_SELL_VOLUME_IN_USD
        #[serde(rename = "prevSellVolumeInUsd")]
        pub prev_sell_volume_in_usd: ::std::string::String,
        ///DTO.TOKEN.TRADE_STAT.PERIOD.PREV_SELLERS
        #[serde(rename = "prevSellers")]
        pub prev_sellers: ::std::string::String,
        ///DTO.TOKEN.TRADE_STAT.PERIOD.PREV_SELLS
        #[serde(rename = "prevSells")]
        pub prev_sells: ::std::string::String,
        ///DTO.TOKEN.TRADE_STAT.PERIOD.PREV_TRADES
        #[serde(rename = "prevTrades")]
        pub prev_trades: ::std::string::String,
        ///DTO.TOKEN.TRADE_STAT.PERIOD.PRICE_CHANGE_RATIO_IN_USD
        #[serde(rename = "priceChangeRatioInUsd")]
        pub price_change_ratio_in_usd: ::std::string::String,
        ///DTO.TOKEN.TRADE_STAT.PERIOD.SELL_VOLUME
        #[serde(rename = "sellVolume")]
        pub sell_volume: ::std::string::String,
        ///DTO.TOKEN.TRADE_STAT.PERIOD.SELL_VOLUME_IN_NATIVE
        #[serde(rename = "sellVolumeInNative")]
        pub sell_volume_in_native: ::std::string::String,
        ///DTO.TOKEN.TRADE_STAT.PERIOD.SELL_VOLUME_IN_USD
        #[serde(rename = "sellVolumeInUsd")]
        pub sell_volume_in_usd: ::std::string::String,
        ///DTO.TOKEN.TRADE_STAT.PERIOD.SELLERS
        pub sellers: ::std::string::String,
        ///DTO.TOKEN.TRADE_STAT.PERIOD.SELLS
        pub sells: ::std::string::String,
        ///DTO.TOKEN.TRADE_STAT.PERIOD.TOTAL_VOLUME_IN_NATIVE
        #[serde(rename = "totalVolumeInNative")]
        pub total_volume_in_native: ::std::string::String,
        ///DTO.TOKEN.TRADE_STAT.PERIOD.TOTAL_VOLUME_IN_USD
        #[serde(rename = "totalVolumeInUsd")]
        pub total_volume_in_usd: ::std::string::String,
        ///DTO.TOKEN.TRADE_STAT.PERIOD.TRADERS
        pub traders: ::std::string::String,
        ///DTO.TOKEN.TRADE_STAT.PERIOD.TRADES
        pub trades: ::std::string::String,
        ///DTO.TOKEN.TRADE_STAT.PERIOD.UPDATED_AT
        #[serde(
            rename = "updatedAt",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub updated_at: ::std::option::Option<::std::string::String>,
        ///DTO.TOKEN.TRADE_STAT.PERIOD.VOLUME_CHANGE_RATIO
        #[serde(
            rename = "volumeChangeRatio",
            default,
            skip_serializing_if = "::serde_json::Map::is_empty"
        )]
        pub volume_change_ratio: ::serde_json::Map<
            ::std::string::String,
            ::serde_json::Value,
        >,
    }
    impl ::std::convert::From<&TokenTradeStatPeriod> for TokenTradeStatPeriod {
        fn from(value: &TokenTradeStatPeriod) -> Self {
            value.clone()
        }
    }
    impl TokenTradeStatPeriod {
        pub fn builder() -> builder::TokenTradeStatPeriod {
            Default::default()
        }
    }
    ///`TokenTrader`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "address"
    ///  ],
    ///  "properties": {
    ///    "address": {
    ///      "description": "DTO.TOKEN_TRADER.ADDRESS",
    ///      "type": "string"
    ///    },
    ///    "blockHash": {
    ///      "description": "DTO.TOKEN_TRADER.BLOCK_HASH",
    ///      "type": "string"
    ///    },
    ///    "blockHeight": {
    ///      "description": "DTO.TOKEN_TRADER.BLOCK_HEIGHT",
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "blockSlot": {
    ///      "description": "DTO.TOKEN_TRADER.BLOCK_SLOT",
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "blockTimestamp": {
    ///      "description": "DTO.TOKEN_TRADER.BLOCK_TIMESTAMP",
    ///      "type": "string",
    ///      "format": "date-time"
    ///    },
    ///    "onchainCreatedAt": {
    ///      "description": "DTO.TOKEN_TRADER.ONCHAIN_CREATED_AT",
    ///      "type": "object"
    ///    },
    ///    "percentileRankTradeAmountInUsd": {
    ///      "description": "DTO.TOKEN_TRADER.PERCENTILE_RANK_TRADE_AMOUNT_IN_USD",
    ///      "type": "string"
    ///    },
    ///    "percentileRankTradeCount": {
    ///      "description": "DTO.TOKEN_TRADER.PERCENTILE_RANK_TRADE_COUNT",
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "rankTradeAmountInUsd": {
    ///      "description": "DTO.TOKEN_TRADER.RANK_TRADE_AMOUNT_IN_USD",
    ///      "type": "string"
    ///    },
    ///    "tradeAmountInNative": {
    ///      "description": "DTO.TOKEN_TRADER.TRADE_AMOUNT_IN_NATIVE",
    ///      "type": "string"
    ///    },
    ///    "tradeAmountInUsd": {
    ///      "description": "DTO.TOKEN_TRADER.TRADE_AMOUNT_IN_USD",
    ///      "type": "string"
    ///    },
    ///    "tradeCount": {
    ///      "description": "DTO.TOKEN_TRADER.TRADE_COUNT",
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "transactionSignature": {
    ///      "description": "DTO.TOKEN_TRADER.TRANSACTION_SIGNATURE",
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct TokenTrader {
        ///DTO.TOKEN_TRADER.ADDRESS
        pub address: ::std::string::String,
        ///DTO.TOKEN_TRADER.BLOCK_HASH
        #[serde(
            rename = "blockHash",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub block_hash: ::std::option::Option<::std::string::String>,
        ///DTO.TOKEN_TRADER.BLOCK_HEIGHT
        #[serde(
            rename = "blockHeight",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub block_height: ::std::option::Option<i64>,
        ///DTO.TOKEN_TRADER.BLOCK_SLOT
        #[serde(
            rename = "blockSlot",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub block_slot: ::std::option::Option<i64>,
        ///DTO.TOKEN_TRADER.BLOCK_TIMESTAMP
        #[serde(
            rename = "blockTimestamp",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub block_timestamp: ::std::option::Option<
            ::chrono::DateTime<::chrono::offset::Utc>,
        >,
        ///DTO.TOKEN_TRADER.ONCHAIN_CREATED_AT
        #[serde(
            rename = "onchainCreatedAt",
            default,
            skip_serializing_if = "::serde_json::Map::is_empty"
        )]
        pub onchain_created_at: ::serde_json::Map<
            ::std::string::String,
            ::serde_json::Value,
        >,
        ///DTO.TOKEN_TRADER.PERCENTILE_RANK_TRADE_AMOUNT_IN_USD
        #[serde(
            rename = "percentileRankTradeAmountInUsd",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub percentile_rank_trade_amount_in_usd: ::std::option::Option<
            ::std::string::String,
        >,
        ///DTO.TOKEN_TRADER.PERCENTILE_RANK_TRADE_COUNT
        #[serde(
            rename = "percentileRankTradeCount",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub percentile_rank_trade_count: ::std::option::Option<i64>,
        ///DTO.TOKEN_TRADER.RANK_TRADE_AMOUNT_IN_USD
        #[serde(
            rename = "rankTradeAmountInUsd",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub rank_trade_amount_in_usd: ::std::option::Option<::std::string::String>,
        ///DTO.TOKEN_TRADER.TRADE_AMOUNT_IN_NATIVE
        #[serde(
            rename = "tradeAmountInNative",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub trade_amount_in_native: ::std::option::Option<::std::string::String>,
        ///DTO.TOKEN_TRADER.TRADE_AMOUNT_IN_USD
        #[serde(
            rename = "tradeAmountInUsd",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub trade_amount_in_usd: ::std::option::Option<::std::string::String>,
        ///DTO.TOKEN_TRADER.TRADE_COUNT
        #[serde(
            rename = "tradeCount",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub trade_count: ::std::option::Option<i64>,
        ///DTO.TOKEN_TRADER.TRANSACTION_SIGNATURE
        #[serde(
            rename = "transactionSignature",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub transaction_signature: ::std::option::Option<::std::string::String>,
    }
    impl ::std::convert::From<&TokenTrader> for TokenTrader {
        fn from(value: &TokenTrader) -> Self {
            value.clone()
        }
    }
    impl TokenTrader {
        pub fn builder() -> builder::TokenTrader {
            Default::default()
        }
    }
    ///`TokenTraderTag`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "string",
    ///  "enum": [
    ///    "fresh",
    ///    "sandwish",
    ///    "bundle",
    ///    "sniper",
    ///    "dev",
    ///    "pro",
    ///    "insider",
    ///    "kol",
    ///    "bluechip",
    ///    "smart"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum TokenTraderTag {
        #[serde(rename = "fresh")]
        Fresh,
        #[serde(rename = "sandwish")]
        Sandwish,
        #[serde(rename = "bundle")]
        Bundle,
        #[serde(rename = "sniper")]
        Sniper,
        #[serde(rename = "dev")]
        Dev,
        #[serde(rename = "pro")]
        Pro,
        #[serde(rename = "insider")]
        Insider,
        #[serde(rename = "kol")]
        Kol,
        #[serde(rename = "bluechip")]
        Bluechip,
        #[serde(rename = "smart")]
        Smart,
    }
    impl ::std::convert::From<&Self> for TokenTraderTag {
        fn from(value: &TokenTraderTag) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for TokenTraderTag {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::Fresh => f.write_str("fresh"),
                Self::Sandwish => f.write_str("sandwish"),
                Self::Bundle => f.write_str("bundle"),
                Self::Sniper => f.write_str("sniper"),
                Self::Dev => f.write_str("dev"),
                Self::Pro => f.write_str("pro"),
                Self::Insider => f.write_str("insider"),
                Self::Kol => f.write_str("kol"),
                Self::Bluechip => f.write_str("bluechip"),
                Self::Smart => f.write_str("smart"),
            }
        }
    }
    impl ::std::str::FromStr for TokenTraderTag {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "fresh" => Ok(Self::Fresh),
                "sandwish" => Ok(Self::Sandwish),
                "bundle" => Ok(Self::Bundle),
                "sniper" => Ok(Self::Sniper),
                "dev" => Ok(Self::Dev),
                "pro" => Ok(Self::Pro),
                "insider" => Ok(Self::Insider),
                "kol" => Ok(Self::Kol),
                "bluechip" => Ok(Self::Bluechip),
                "smart" => Ok(Self::Smart),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for TokenTraderTag {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String> for TokenTraderTag {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for TokenTraderTag {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    ///`TokenTransferItemDto`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "action",
    ///    "amount",
    ///    "blockNumber",
    ///    "blockTime",
    ///    "decimals",
    ///    "flow",
    ///    "fromAddress",
    ///    "fromTokenAccount",
    ///    "name",
    ///    "price",
    ///    "symbol",
    ///    "toAddress",
    ///    "toTokenAccount",
    ///    "tokenAddress",
    ///    "txHash",
    ///    "value"
    ///  ],
    ///  "properties": {
    ///    "action": {
    ///      "description": "DTO.TOKEN.TRANSFER.ACTION",
    ///      "examples": [
    ///        "transfer"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "amount": {
    ///      "description": "DTO.TOKEN.TRANSFER.AMOUNT",
    ///      "examples": [
    ///        "149.05"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "blockNumber": {
    ///      "description": "DTO.TOKEN.TRANSFER.BLOCK_NUMBER",
    ///      "examples": [
    ///        398544039
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "blockTime": {
    ///      "description": "DTO.TOKEN.TRANSFER.BLOCK_TIME",
    ///      "examples": [
    ///        1770508507000
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "decimals": {
    ///      "description": "DTO.TOKEN.TRANSFER.DECIMALS",
    ///      "examples": [
    ///        6
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "flow": {
    ///      "description": "DTO.TOKEN.TRANSFER.FLOW",
    ///      "examples": [
    ///        "out"
    ///      ],
    ///      "type": "string",
    ///      "enum": [
    ///        "in",
    ///        "out"
    ///      ]
    ///    },
    ///    "fromAddress": {
    ///      "description": "DTO.TOKEN.TRANSFER.FROM_ADDRESS",
    ///      "examples": [
    ///        "BLes958hcLyJcXibidW4fmWpCjoXmJEdoewY5itHLZgi"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "fromTokenAccount": {
    ///      "description": "DTO.TOKEN.TRANSFER.FROM_TOKEN_ACCOUNT",
    ///      "examples": [
    ///        "CLoj1mryCYGpNhY1k27UJLeoaAuzM5gLC1dyWX58YLCg"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "logoUri": {
    ///      "description": "DTO.TOKEN.TRANSFER.LOGO_URI",
    ///      "examples": [
    ///        "https://..."
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "name": {
    ///      "description": "DTO.TOKEN.TRANSFER.NAME",
    ///      "examples": [
    ///        "USD Coin"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "price": {
    ///      "description": "DTO.TOKEN.TRANSFER.PRICE",
    ///      "examples": [
    ///        "1.00"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "symbol": {
    ///      "description": "DTO.TOKEN.TRANSFER.SYMBOL",
    ///      "examples": [
    ///        "USDC"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "toAddress": {
    ///      "description": "DTO.TOKEN.TRANSFER.TO_ADDRESS",
    ///      "examples": [
    ///        "ARu4n5mFdZogZAravu7CcizaojWnS6oqka37gdLT5SZn"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "toTokenAccount": {
    ///      "description": "DTO.TOKEN.TRANSFER.TO_TOKEN_ACCOUNT",
    ///      "examples": [
    ///        "8XrtGP8RG33AnrN2yJ6H3gnXPNQ3dYXKqM72bpzhcsd6"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "tokenAddress": {
    ///      "description": "DTO.TOKEN.TRANSFER.TOKEN_ADDRESS",
    ///      "examples": [
    ///        "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "txHash": {
    ///      "description": "DTO.TOKEN.TRANSFER.TX_HASH",
    ///      "examples": [
    ///        "2vLYZuCrKARicrXRDf2eGnzaKR9PP6qFFuzgPCHUNAnw..."
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "value": {
    ///      "description": "DTO.TOKEN.TRANSFER.VALUE",
    ///      "examples": [
    ///        "149.05"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct TokenTransferItemDto {
        ///DTO.TOKEN.TRANSFER.ACTION
        pub action: ::std::string::String,
        ///DTO.TOKEN.TRANSFER.AMOUNT
        pub amount: ::std::string::String,
        ///DTO.TOKEN.TRANSFER.BLOCK_NUMBER
        #[serde(rename = "blockNumber")]
        pub block_number: i64,
        ///DTO.TOKEN.TRANSFER.BLOCK_TIME
        #[serde(rename = "blockTime")]
        pub block_time: i64,
        ///DTO.TOKEN.TRANSFER.DECIMALS
        pub decimals: i64,
        ///DTO.TOKEN.TRANSFER.FLOW
        pub flow: TokenTransferItemDtoFlow,
        ///DTO.TOKEN.TRANSFER.FROM_ADDRESS
        #[serde(rename = "fromAddress")]
        pub from_address: ::std::string::String,
        ///DTO.TOKEN.TRANSFER.FROM_TOKEN_ACCOUNT
        #[serde(rename = "fromTokenAccount")]
        pub from_token_account: ::std::string::String,
        ///DTO.TOKEN.TRANSFER.LOGO_URI
        #[serde(
            rename = "logoUri",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub logo_uri: ::std::option::Option<::std::string::String>,
        ///DTO.TOKEN.TRANSFER.NAME
        pub name: ::std::string::String,
        ///DTO.TOKEN.TRANSFER.PRICE
        pub price: ::std::string::String,
        ///DTO.TOKEN.TRANSFER.SYMBOL
        pub symbol: ::std::string::String,
        ///DTO.TOKEN.TRANSFER.TO_ADDRESS
        #[serde(rename = "toAddress")]
        pub to_address: ::std::string::String,
        ///DTO.TOKEN.TRANSFER.TO_TOKEN_ACCOUNT
        #[serde(rename = "toTokenAccount")]
        pub to_token_account: ::std::string::String,
        ///DTO.TOKEN.TRANSFER.TOKEN_ADDRESS
        #[serde(rename = "tokenAddress")]
        pub token_address: ::std::string::String,
        ///DTO.TOKEN.TRANSFER.TX_HASH
        #[serde(rename = "txHash")]
        pub tx_hash: ::std::string::String,
        ///DTO.TOKEN.TRANSFER.VALUE
        pub value: ::std::string::String,
    }
    impl ::std::convert::From<&TokenTransferItemDto> for TokenTransferItemDto {
        fn from(value: &TokenTransferItemDto) -> Self {
            value.clone()
        }
    }
    impl TokenTransferItemDto {
        pub fn builder() -> builder::TokenTransferItemDto {
            Default::default()
        }
    }
    ///DTO.TOKEN.TRANSFER.FLOW
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "DTO.TOKEN.TRANSFER.FLOW",
    ///  "examples": [
    ///    "out"
    ///  ],
    ///  "type": "string",
    ///  "enum": [
    ///    "in",
    ///    "out"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum TokenTransferItemDtoFlow {
        #[serde(rename = "in")]
        In,
        #[serde(rename = "out")]
        Out,
    }
    impl ::std::convert::From<&Self> for TokenTransferItemDtoFlow {
        fn from(value: &TokenTransferItemDtoFlow) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for TokenTransferItemDtoFlow {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::In => f.write_str("in"),
                Self::Out => f.write_str("out"),
            }
        }
    }
    impl ::std::str::FromStr for TokenTransferItemDtoFlow {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "in" => Ok(Self::In),
                "out" => Ok(Self::Out),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for TokenTransferItemDtoFlow {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String> for TokenTransferItemDtoFlow {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for TokenTransferItemDtoFlow {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    ///`TokenTransferPage`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "data"
    ///  ],
    ///  "properties": {
    ///    "data": {
    ///      "description": "DTO.PAGE.DATA",
    ///      "type": "array",
    ///      "items": {
    ///        "$ref": "#/components/schemas/TokenTransferItemDTO"
    ///      }
    ///    },
    ///    "endCursor": {
    ///      "description": "DTO.PAGE.END_CURSOR",
    ///      "type": "string"
    ///    },
    ///    "hasNext": {
    ///      "description": "DTO.PAGE.HAS_NEXT",
    ///      "default": false,
    ///      "type": "boolean"
    ///    },
    ///    "hasPrev": {
    ///      "description": "DTO.PAGE.HAS_PREV",
    ///      "default": false,
    ///      "type": "boolean"
    ///    },
    ///    "startCursor": {
    ///      "description": "DTO.PAGE.START_CURSOR",
    ///      "type": "string"
    ///    },
    ///    "total": {
    ///      "description": "DTO.PAGE.TOTAL",
    ///      "default": 0,
    ///      "type": "integer",
    ///      "format": "int64"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct TokenTransferPage {
        ///DTO.PAGE.DATA
        pub data: ::std::vec::Vec<TokenTransferItemDto>,
        ///DTO.PAGE.END_CURSOR
        #[serde(
            rename = "endCursor",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub end_cursor: ::std::option::Option<::std::string::String>,
        ///DTO.PAGE.HAS_NEXT
        #[serde(rename = "hasNext", default)]
        pub has_next: bool,
        ///DTO.PAGE.HAS_PREV
        #[serde(rename = "hasPrev", default)]
        pub has_prev: bool,
        ///DTO.PAGE.START_CURSOR
        #[serde(
            rename = "startCursor",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub start_cursor: ::std::option::Option<::std::string::String>,
        ///DTO.PAGE.TOTAL
        #[serde(default)]
        pub total: i64,
    }
    impl ::std::convert::From<&TokenTransferPage> for TokenTransferPage {
        fn from(value: &TokenTransferPage) -> Self {
            value.clone()
        }
    }
    impl TokenTransferPage {
        pub fn builder() -> builder::TokenTransferPage {
            Default::default()
        }
    }
    ///`TokenTransferTotalDto`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "total"
    ///  ],
    ///  "properties": {
    ///    "total": {
    ///      "description": "DTO.TOKEN.TRANSFER.TOTAL",
    ///      "examples": [
    ///        123456
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct TokenTransferTotalDto {
        ///DTO.TOKEN.TRANSFER.TOTAL
        pub total: i64,
    }
    impl ::std::convert::From<&TokenTransferTotalDto> for TokenTransferTotalDto {
        fn from(value: &TokenTransferTotalDto) -> Self {
            value.clone()
        }
    }
    impl TokenTransferTotalDto {
        pub fn builder() -> builder::TokenTransferTotalDto {
            Default::default()
        }
    }
    ///`TokensBalancePage`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "data"
    ///  ],
    ///  "properties": {
    ///    "data": {
    ///      "description": "DTO.PAGE.DATA",
    ///      "type": "array",
    ///      "items": {
    ///        "$ref": "#/components/schemas/WalletNetWorthItemDTO"
    ///      }
    ///    },
    ///    "endCursor": {
    ///      "description": "DTO.PAGE.END_CURSOR",
    ///      "type": "string"
    ///    },
    ///    "hasNext": {
    ///      "description": "DTO.PAGE.HAS_NEXT",
    ///      "default": false,
    ///      "type": "boolean"
    ///    },
    ///    "hasPrev": {
    ///      "description": "DTO.PAGE.HAS_PREV",
    ///      "default": false,
    ///      "type": "boolean"
    ///    },
    ///    "startCursor": {
    ///      "description": "DTO.PAGE.START_CURSOR",
    ///      "type": "string"
    ///    },
    ///    "total": {
    ///      "description": "DTO.PAGE.TOTAL",
    ///      "default": 0,
    ///      "type": "integer",
    ///      "format": "int64"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct TokensBalancePage {
        ///DTO.PAGE.DATA
        pub data: ::std::vec::Vec<WalletNetWorthItemDto>,
        ///DTO.PAGE.END_CURSOR
        #[serde(
            rename = "endCursor",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub end_cursor: ::std::option::Option<::std::string::String>,
        ///DTO.PAGE.HAS_NEXT
        #[serde(rename = "hasNext", default)]
        pub has_next: bool,
        ///DTO.PAGE.HAS_PREV
        #[serde(rename = "hasPrev", default)]
        pub has_prev: bool,
        ///DTO.PAGE.START_CURSOR
        #[serde(
            rename = "startCursor",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub start_cursor: ::std::option::Option<::std::string::String>,
        ///DTO.PAGE.TOTAL
        #[serde(default)]
        pub total: i64,
    }
    impl ::std::convert::From<&TokensBalancePage> for TokensBalancePage {
        fn from(value: &TokensBalancePage) -> Self {
            value.clone()
        }
    }
    impl TokensBalancePage {
        pub fn builder() -> builder::TokensBalancePage {
            Default::default()
        }
    }
    ///`TopTradersDto`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "buyAmount",
    ///    "buyAmountInNative",
    ///    "buyAmountInUsd",
    ///    "buyCount",
    ///    "sellAmount",
    ///    "sellAmountInNative",
    ///    "sellAmountInUsd",
    ///    "sellCount",
    ///    "tokenAddress",
    ///    "tradeAmount",
    ///    "tradeCount",
    ///    "walletAddress"
    ///  ],
    ///  "properties": {
    ///    "buyAmount": {
    ///      "description": "DTO.TRADE.TOP_TRADERS.BUY_AMOUNT",
    ///      "examples": [
    ///        "600000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "buyAmountInNative": {
    ///      "description": "DTO.TRADE.TOP_TRADERS.BUY_AMOUNT_IN_NATIVE",
    ///      "examples": [
    ///        "100.5"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "buyAmountInUsd": {
    ///      "description": "DTO.TRADE.TOP_TRADERS.BUY_AMOUNT_IN_USD",
    ///      "examples": [
    ///        "12000.50"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "buyCount": {
    ///      "description": "DTO.TRADE.TOP_TRADERS.BUY_COUNT",
    ///      "examples": [
    ///        60
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "sellAmount": {
    ///      "description": "DTO.TRADE.TOP_TRADERS.SELL_AMOUNT",
    ///      "examples": [
    ///        "400000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "sellAmountInNative": {
    ///      "description": "DTO.TRADE.TOP_TRADERS.SELL_AMOUNT_IN_NATIVE",
    ///      "examples": [
    ///        "66.8"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "sellAmountInUsd": {
    ///      "description": "DTO.TRADE.TOP_TRADERS.SELL_AMOUNT_IN_USD",
    ///      "examples": [
    ///        "8000.30"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "sellCount": {
    ///      "description": "DTO.TRADE.TOP_TRADERS.SELL_COUNT",
    ///      "examples": [
    ///        40
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "tokenAddress": {
    ///      "description": "DTO.TRADE.TOP_TRADERS.TOKEN_ADDRESS",
    ///      "examples": [
    ///        "6p6xgHyF7AeE6TZkSmFsko444wqoP15icUSqi2jfGiPN"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "tradeAmount": {
    ///      "description": "DTO.TRADE.TOP_TRADERS.TRADE_AMOUNT",
    ///      "examples": [
    ///        "1000000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "tradeCount": {
    ///      "description": "DTO.TRADE.TOP_TRADERS.TRADE_COUNT",
    ///      "examples": [
    ///        100
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "walletAddress": {
    ///      "description": "DTO.TRADE.TOP_TRADERS.WALLET_ADDRESS",
    ///      "examples": [
    ///        "3xd4LGVWtYXLBspR6X5JWbW49NXmEehfPtX6Kqx98b4w"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct TopTradersDto {
        ///DTO.TRADE.TOP_TRADERS.BUY_AMOUNT
        #[serde(rename = "buyAmount")]
        pub buy_amount: ::std::string::String,
        ///DTO.TRADE.TOP_TRADERS.BUY_AMOUNT_IN_NATIVE
        #[serde(rename = "buyAmountInNative")]
        pub buy_amount_in_native: ::std::string::String,
        ///DTO.TRADE.TOP_TRADERS.BUY_AMOUNT_IN_USD
        #[serde(rename = "buyAmountInUsd")]
        pub buy_amount_in_usd: ::std::string::String,
        ///DTO.TRADE.TOP_TRADERS.BUY_COUNT
        #[serde(rename = "buyCount")]
        pub buy_count: i64,
        ///DTO.TRADE.TOP_TRADERS.SELL_AMOUNT
        #[serde(rename = "sellAmount")]
        pub sell_amount: ::std::string::String,
        ///DTO.TRADE.TOP_TRADERS.SELL_AMOUNT_IN_NATIVE
        #[serde(rename = "sellAmountInNative")]
        pub sell_amount_in_native: ::std::string::String,
        ///DTO.TRADE.TOP_TRADERS.SELL_AMOUNT_IN_USD
        #[serde(rename = "sellAmountInUsd")]
        pub sell_amount_in_usd: ::std::string::String,
        ///DTO.TRADE.TOP_TRADERS.SELL_COUNT
        #[serde(rename = "sellCount")]
        pub sell_count: i64,
        ///DTO.TRADE.TOP_TRADERS.TOKEN_ADDRESS
        #[serde(rename = "tokenAddress")]
        pub token_address: ::std::string::String,
        ///DTO.TRADE.TOP_TRADERS.TRADE_AMOUNT
        #[serde(rename = "tradeAmount")]
        pub trade_amount: ::std::string::String,
        ///DTO.TRADE.TOP_TRADERS.TRADE_COUNT
        #[serde(rename = "tradeCount")]
        pub trade_count: i64,
        ///DTO.TRADE.TOP_TRADERS.WALLET_ADDRESS
        #[serde(rename = "walletAddress")]
        pub wallet_address: ::std::string::String,
    }
    impl ::std::convert::From<&TopTradersDto> for TopTradersDto {
        fn from(value: &TopTradersDto) -> Self {
            value.clone()
        }
    }
    impl TopTradersDto {
        pub fn builder() -> builder::TopTradersDto {
            Default::default()
        }
    }
    ///`TopTradersPage`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "data"
    ///  ],
    ///  "properties": {
    ///    "data": {
    ///      "description": "DTO.TRADE.TOP_TRADERS.PAGE.DATA",
    ///      "type": "array",
    ///      "items": {
    ///        "$ref": "#/components/schemas/TopTradersDTO"
    ///      }
    ///    },
    ///    "endCursor": {
    ///      "description": "DTO.PAGE.END_CURSOR",
    ///      "type": "string"
    ///    },
    ///    "hasNext": {
    ///      "description": "DTO.PAGE.HAS_NEXT",
    ///      "default": false,
    ///      "type": "boolean"
    ///    },
    ///    "hasPrev": {
    ///      "description": "DTO.PAGE.HAS_PREV",
    ///      "default": false,
    ///      "type": "boolean"
    ///    },
    ///    "startCursor": {
    ///      "description": "DTO.PAGE.START_CURSOR",
    ///      "type": "string"
    ///    },
    ///    "total": {
    ///      "description": "DTO.PAGE.TOTAL",
    ///      "default": 0,
    ///      "type": "integer",
    ///      "format": "int64"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct TopTradersPage {
        ///DTO.TRADE.TOP_TRADERS.PAGE.DATA
        pub data: ::std::vec::Vec<TopTradersDto>,
        ///DTO.PAGE.END_CURSOR
        #[serde(
            rename = "endCursor",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub end_cursor: ::std::option::Option<::std::string::String>,
        ///DTO.PAGE.HAS_NEXT
        #[serde(rename = "hasNext", default)]
        pub has_next: bool,
        ///DTO.PAGE.HAS_PREV
        #[serde(rename = "hasPrev", default)]
        pub has_prev: bool,
        ///DTO.PAGE.START_CURSOR
        #[serde(
            rename = "startCursor",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub start_cursor: ::std::option::Option<::std::string::String>,
        ///DTO.PAGE.TOTAL
        #[serde(default)]
        pub total: i64,
    }
    impl ::std::convert::From<&TopTradersPage> for TopTradersPage {
        fn from(value: &TopTradersPage) -> Self {
            value.clone()
        }
    }
    impl TopTradersPage {
        pub fn builder() -> builder::TopTradersPage {
            Default::default()
        }
    }
    ///`TradeDetailDto`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "accountOwnerAddress",
    ///    "blockHeight",
    ///    "blockTimestamp",
    ///    "chain",
    ///    "dexImage",
    ///    "dexProgramAddress",
    ///    "dexProtocolFamily",
    ///    "poolAddress",
    ///    "sideTokenAddress",
    ///    "sideTokenAmount",
    ///    "sideTokenAmountInNative",
    ///    "sideTokenAmountInUsd",
    ///    "sideTokenImageUrl",
    ///    "sideTokenName",
    ///    "sideTokenPriceInNative",
    ///    "sideTokenPriceInUsd",
    ///    "sideTokenSymbol",
    ///    "status",
    ///    "tokenAddress",
    ///    "tokenAmount",
    ///    "tokenAmountInNative",
    ///    "tokenAmountInUsd",
    ///    "tokenImageUrl",
    ///    "tokenName",
    ///    "tokenPriceInNative",
    ///    "tokenPriceInUsd",
    ///    "tokenSymbol",
    ///    "transactionSignature",
    ///    "type"
    ///  ],
    ///  "properties": {
    ///    "accountOwnerAddress": {
    ///      "description": "DTO.TRADE.DETAIL.ACCOUNT_OWNER_ADDRESS",
    ///      "type": "string"
    ///    },
    ///    "blockHeight": {
    ///      "description": "DTO.TRADE.DETAIL.BLOCK_HEIGHT",
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "blockTimestamp": {
    ///      "description": "DTO.TRADE.DETAIL.BLOCK_TIMESTAMP",
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "chain": {
    ///      "description": "DTO.TRADE.DETAIL.CHAIN",
    ///      "type": "string"
    ///    },
    ///    "dexImage": {
    ///      "description": "DTO.TRADE.DETAIL.DEX_IMAGE",
    ///      "type": "string"
    ///    },
    ///    "dexProgramAddress": {
    ///      "description": "DTO.TRADE.DETAIL.DEX_PROGRAM_ADDRESS",
    ///      "type": "string"
    ///    },
    ///    "dexProtocolFamily": {
    ///      "description": "DTO.TRADE.DETAIL.DEX_PROTOCOL_FAMILY",
    ///      "type": "string"
    ///    },
    ///    "poolAddress": {
    ///      "description": "DTO.TRADE.DETAIL.POOL_ADDRESS",
    ///      "type": "string"
    ///    },
    ///    "sideTokenAddress": {
    ///      "description": "DTO.TRADE.DETAIL.SIDE_TOKEN_ADDRESS",
    ///      "type": "string"
    ///    },
    ///    "sideTokenAmount": {
    ///      "description": "DTO.TRADE.DETAIL.SIDE_TOKEN_AMOUNT",
    ///      "type": "string"
    ///    },
    ///    "sideTokenAmountInNative": {
    ///      "description": "DTO.TRADE.DETAIL.SIDE_TOKEN_AMOUNT_IN_NATIVE",
    ///      "type": "string"
    ///    },
    ///    "sideTokenAmountInUsd": {
    ///      "description": "DTO.TRADE.DETAIL.SIDE_TOKEN_AMOUNT_IN_USD",
    ///      "type": "string"
    ///    },
    ///    "sideTokenImageUrl": {
    ///      "description": "DTO.TRADE.DETAIL.SIDE_TOKEN_IMAGE_URL",
    ///      "type": "string"
    ///    },
    ///    "sideTokenName": {
    ///      "description": "DTO.TRADE.DETAIL.SIDE_TOKEN_NAME",
    ///      "type": "string"
    ///    },
    ///    "sideTokenPriceInNative": {
    ///      "description": "DTO.TRADE.DETAIL.SIDE_TOKEN_PRICE_IN_NATIVE",
    ///      "type": "string"
    ///    },
    ///    "sideTokenPriceInUsd": {
    ///      "description": "DTO.TRADE.DETAIL.SIDE_TOKEN_PRICE_IN_USD",
    ///      "type": "string"
    ///    },
    ///    "sideTokenSymbol": {
    ///      "description": "DTO.TRADE.DETAIL.SIDE_TOKEN_SYMBOL",
    ///      "type": "string"
    ///    },
    ///    "status": {
    ///      "description": "DTO.TRADE.DETAIL.STATUS",
    ///      "type": "string"
    ///    },
    ///    "tokenAddress": {
    ///      "description": "DTO.TRADE.DETAIL.TOKEN_ADDRESS",
    ///      "type": "string"
    ///    },
    ///    "tokenAmount": {
    ///      "description": "DTO.TRADE.DETAIL.TOKEN_AMOUNT",
    ///      "type": "string"
    ///    },
    ///    "tokenAmountInNative": {
    ///      "description": "DTO.TRADE.DETAIL.TOKEN_AMOUNT_IN_NATIVE",
    ///      "type": "string"
    ///    },
    ///    "tokenAmountInUsd": {
    ///      "description": "DTO.TRADE.DETAIL.TOKEN_AMOUNT_IN_USD",
    ///      "type": "string"
    ///    },
    ///    "tokenImageUrl": {
    ///      "description": "DTO.TRADE.DETAIL.TOKEN_IMAGE_URL",
    ///      "type": "string"
    ///    },
    ///    "tokenName": {
    ///      "description": "DTO.TRADE.DETAIL.TOKEN_NAME",
    ///      "type": "string"
    ///    },
    ///    "tokenPriceInNative": {
    ///      "description": "DTO.TRADE.DETAIL.TOKEN_PRICE_IN_NATIVE",
    ///      "type": "string"
    ///    },
    ///    "tokenPriceInUsd": {
    ///      "description": "DTO.TRADE.DETAIL.TOKEN_PRICE_IN_USD",
    ///      "type": "string"
    ///    },
    ///    "tokenSymbol": {
    ///      "description": "DTO.TRADE.DETAIL.TOKEN_SYMBOL",
    ///      "type": "string"
    ///    },
    ///    "transactionSignature": {
    ///      "description": "DTO.TRADE.DETAIL.TRANSACTION_SIGNATURE",
    ///      "type": "string"
    ///    },
    ///    "type": {
    ///      "description": "DTO.TRADE.DETAIL.TYPE",
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct TradeDetailDto {
        ///DTO.TRADE.DETAIL.ACCOUNT_OWNER_ADDRESS
        #[serde(rename = "accountOwnerAddress")]
        pub account_owner_address: ::std::string::String,
        ///DTO.TRADE.DETAIL.BLOCK_HEIGHT
        #[serde(rename = "blockHeight")]
        pub block_height: i64,
        ///DTO.TRADE.DETAIL.BLOCK_TIMESTAMP
        #[serde(rename = "blockTimestamp")]
        pub block_timestamp: i64,
        ///DTO.TRADE.DETAIL.CHAIN
        pub chain: ::std::string::String,
        ///DTO.TRADE.DETAIL.DEX_IMAGE
        #[serde(rename = "dexImage")]
        pub dex_image: ::std::string::String,
        ///DTO.TRADE.DETAIL.DEX_PROGRAM_ADDRESS
        #[serde(rename = "dexProgramAddress")]
        pub dex_program_address: ::std::string::String,
        ///DTO.TRADE.DETAIL.DEX_PROTOCOL_FAMILY
        #[serde(rename = "dexProtocolFamily")]
        pub dex_protocol_family: ::std::string::String,
        ///DTO.TRADE.DETAIL.POOL_ADDRESS
        #[serde(rename = "poolAddress")]
        pub pool_address: ::std::string::String,
        ///DTO.TRADE.DETAIL.SIDE_TOKEN_ADDRESS
        #[serde(rename = "sideTokenAddress")]
        pub side_token_address: ::std::string::String,
        ///DTO.TRADE.DETAIL.SIDE_TOKEN_AMOUNT
        #[serde(rename = "sideTokenAmount")]
        pub side_token_amount: ::std::string::String,
        ///DTO.TRADE.DETAIL.SIDE_TOKEN_AMOUNT_IN_NATIVE
        #[serde(rename = "sideTokenAmountInNative")]
        pub side_token_amount_in_native: ::std::string::String,
        ///DTO.TRADE.DETAIL.SIDE_TOKEN_AMOUNT_IN_USD
        #[serde(rename = "sideTokenAmountInUsd")]
        pub side_token_amount_in_usd: ::std::string::String,
        ///DTO.TRADE.DETAIL.SIDE_TOKEN_IMAGE_URL
        #[serde(rename = "sideTokenImageUrl")]
        pub side_token_image_url: ::std::string::String,
        ///DTO.TRADE.DETAIL.SIDE_TOKEN_NAME
        #[serde(rename = "sideTokenName")]
        pub side_token_name: ::std::string::String,
        ///DTO.TRADE.DETAIL.SIDE_TOKEN_PRICE_IN_NATIVE
        #[serde(rename = "sideTokenPriceInNative")]
        pub side_token_price_in_native: ::std::string::String,
        ///DTO.TRADE.DETAIL.SIDE_TOKEN_PRICE_IN_USD
        #[serde(rename = "sideTokenPriceInUsd")]
        pub side_token_price_in_usd: ::std::string::String,
        ///DTO.TRADE.DETAIL.SIDE_TOKEN_SYMBOL
        #[serde(rename = "sideTokenSymbol")]
        pub side_token_symbol: ::std::string::String,
        ///DTO.TRADE.DETAIL.STATUS
        pub status: ::std::string::String,
        ///DTO.TRADE.DETAIL.TOKEN_ADDRESS
        #[serde(rename = "tokenAddress")]
        pub token_address: ::std::string::String,
        ///DTO.TRADE.DETAIL.TOKEN_AMOUNT
        #[serde(rename = "tokenAmount")]
        pub token_amount: ::std::string::String,
        ///DTO.TRADE.DETAIL.TOKEN_AMOUNT_IN_NATIVE
        #[serde(rename = "tokenAmountInNative")]
        pub token_amount_in_native: ::std::string::String,
        ///DTO.TRADE.DETAIL.TOKEN_AMOUNT_IN_USD
        #[serde(rename = "tokenAmountInUsd")]
        pub token_amount_in_usd: ::std::string::String,
        ///DTO.TRADE.DETAIL.TOKEN_IMAGE_URL
        #[serde(rename = "tokenImageUrl")]
        pub token_image_url: ::std::string::String,
        ///DTO.TRADE.DETAIL.TOKEN_NAME
        #[serde(rename = "tokenName")]
        pub token_name: ::std::string::String,
        ///DTO.TRADE.DETAIL.TOKEN_PRICE_IN_NATIVE
        #[serde(rename = "tokenPriceInNative")]
        pub token_price_in_native: ::std::string::String,
        ///DTO.TRADE.DETAIL.TOKEN_PRICE_IN_USD
        #[serde(rename = "tokenPriceInUsd")]
        pub token_price_in_usd: ::std::string::String,
        ///DTO.TRADE.DETAIL.TOKEN_SYMBOL
        #[serde(rename = "tokenSymbol")]
        pub token_symbol: ::std::string::String,
        ///DTO.TRADE.DETAIL.TRANSACTION_SIGNATURE
        #[serde(rename = "transactionSignature")]
        pub transaction_signature: ::std::string::String,
        ///DTO.TRADE.DETAIL.TYPE
        #[serde(rename = "type")]
        pub type_: ::std::string::String,
    }
    impl ::std::convert::From<&TradeDetailDto> for TradeDetailDto {
        fn from(value: &TradeDetailDto) -> Self {
            value.clone()
        }
    }
    impl TradeDetailDto {
        pub fn builder() -> builder::TradeDetailDto {
            Default::default()
        }
    }
    ///`TradeEvent`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "amountInUsd",
    ///    "baseAmount",
    ///    "buyCostUsd",
    ///    "event",
    ///    "id",
    ///    "maker",
    ///    "priceInUsd",
    ///    "quoteAddress",
    ///    "quoteAmount",
    ///    "quoteSymbol",
    ///    "timestamp",
    ///    "tokenAddress",
    ///    "txHash"
    ///  ],
    ///  "properties": {
    ///    "amountInUsd": {
    ///      "description": "DTO.TRADE.AMOUNT_IN_USD",
    ///      "examples": [
    ///        "0.18691810584000000000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "baseAmount": {
    ///      "description": "DTO.TRADE.BASE_AMOUNT",
    ///      "examples": [
    ///        "3.49753400000000000000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "buyCostUsd": {
    ///      "description": "DTO.TRADE.BUY_COST_USD",
    ///      "examples": [
    ///        ""
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "event": {
    ///      "description": "DTO.TRADE.EVENT",
    ///      "examples": [
    ///        "buy"
    ///      ],
    ///      "allOf": [
    ///        {
    ///          "$ref": "#/components/schemas/TradeType"
    ///        }
    ///      ]
    ///    },
    ///    "id": {
    ///      "description": "DTO.TRADE.ID",
    ///      "examples": [
    ///        "MDAzMTc4OTQ0OTUxNTcwMDAwMg=="
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "maker": {
    ///      "description": "DTO.TRADE.MAKER",
    ///      "examples": [
    ///        "GC8vnXWCpC5oDZeCTFLCpeBDHbgPczq1TQqziJctDFY"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "priceInUsd": {
    ///      "description": "DTO.TRADE.PRICE_IN_USD",
    ///      "examples": [
    ///        "0.05344282738637203200"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "quoteAddress": {
    ///      "description": "DTO.TRADE.QUOTE_ADDRESS",
    ///      "examples": [
    ///        "So11111111111111111111111111111111111111112"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "quoteAmount": {
    ///      "description": "DTO.TRADE.QUOTE_AMOUNT",
    ///      "examples": [
    ///        "0.00085986800000000000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "quoteSymbol": {
    ///      "description": "DTO.TRADE.QUOTE_SYMBOL",
    ///      "examples": [
    ///        "SOL"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "timestamp": {
    ///      "description": "DTO.TRADE.TIMESTAMP",
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "tokenAddress": {
    ///      "description": "DTO.TRADE.TOKEN_ADDRESS",
    ///      "examples": [
    ///        "74SBV4zDXxTRgv1pEMoECskKBkZHc2yGPnc7GYVepump"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "txHash": {
    ///      "description": "DTO.TRADE.TX_HASH",
    ///      "examples": [
    ///        "37XpPt9Ak6JiE1V3sftJDtdUsvR9FVFRqkZmoT3dp4BTD9pgyTWn1XgHH6R7NjuJ4pBMAgj8JvZtxQrf4s6NTC5F"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct TradeEvent {
        ///DTO.TRADE.AMOUNT_IN_USD
        #[serde(rename = "amountInUsd")]
        pub amount_in_usd: ::std::string::String,
        ///DTO.TRADE.BASE_AMOUNT
        #[serde(rename = "baseAmount")]
        pub base_amount: ::std::string::String,
        ///DTO.TRADE.BUY_COST_USD
        #[serde(rename = "buyCostUsd")]
        pub buy_cost_usd: ::std::string::String,
        ///DTO.TRADE.EVENT
        pub event: TradeType,
        ///DTO.TRADE.ID
        pub id: ::std::string::String,
        ///DTO.TRADE.MAKER
        pub maker: ::std::string::String,
        ///DTO.TRADE.PRICE_IN_USD
        #[serde(rename = "priceInUsd")]
        pub price_in_usd: ::std::string::String,
        ///DTO.TRADE.QUOTE_ADDRESS
        #[serde(rename = "quoteAddress")]
        pub quote_address: ::std::string::String,
        ///DTO.TRADE.QUOTE_AMOUNT
        #[serde(rename = "quoteAmount")]
        pub quote_amount: ::std::string::String,
        ///DTO.TRADE.QUOTE_SYMBOL
        #[serde(rename = "quoteSymbol")]
        pub quote_symbol: ::std::string::String,
        ///DTO.TRADE.TIMESTAMP
        pub timestamp: i64,
        ///DTO.TRADE.TOKEN_ADDRESS
        #[serde(rename = "tokenAddress")]
        pub token_address: ::std::string::String,
        ///DTO.TRADE.TX_HASH
        #[serde(rename = "txHash")]
        pub tx_hash: ::std::string::String,
    }
    impl ::std::convert::From<&TradeEvent> for TradeEvent {
        fn from(value: &TradeEvent) -> Self {
            value.clone()
        }
    }
    impl TradeEvent {
        pub fn builder() -> builder::TradeEvent {
            Default::default()
        }
    }
    ///`TradePage`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "data"
    ///  ],
    ///  "properties": {
    ///    "data": {
    ///      "description": "DTO.TRADE.PAGE.DATA",
    ///      "type": "array",
    ///      "items": {
    ///        "$ref": "#/components/schemas/TradeDetailDTO"
    ///      }
    ///    },
    ///    "endCursor": {
    ///      "description": "DTO.PAGE.END_CURSOR",
    ///      "type": "string"
    ///    },
    ///    "hasNext": {
    ///      "description": "DTO.PAGE.HAS_NEXT",
    ///      "default": false,
    ///      "type": "boolean"
    ///    },
    ///    "hasPrev": {
    ///      "description": "DTO.PAGE.HAS_PREV",
    ///      "default": false,
    ///      "type": "boolean"
    ///    },
    ///    "startCursor": {
    ///      "description": "DTO.PAGE.START_CURSOR",
    ///      "type": "string"
    ///    },
    ///    "total": {
    ///      "description": "DTO.PAGE.TOTAL",
    ///      "default": 0,
    ///      "type": "integer",
    ///      "format": "int64"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct TradePage {
        ///DTO.TRADE.PAGE.DATA
        pub data: ::std::vec::Vec<TradeDetailDto>,
        ///DTO.PAGE.END_CURSOR
        #[serde(
            rename = "endCursor",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub end_cursor: ::std::option::Option<::std::string::String>,
        ///DTO.PAGE.HAS_NEXT
        #[serde(rename = "hasNext", default)]
        pub has_next: bool,
        ///DTO.PAGE.HAS_PREV
        #[serde(rename = "hasPrev", default)]
        pub has_prev: bool,
        ///DTO.PAGE.START_CURSOR
        #[serde(
            rename = "startCursor",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub start_cursor: ::std::option::Option<::std::string::String>,
        ///DTO.PAGE.TOTAL
        #[serde(default)]
        pub total: i64,
    }
    impl ::std::convert::From<&TradePage> for TradePage {
        fn from(value: &TradePage) -> Self {
            value.clone()
        }
    }
    impl TradePage {
        pub fn builder() -> builder::TradePage {
            Default::default()
        }
    }
    ///`TradeType`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "string",
    ///  "enum": [
    ///    "buy",
    ///    "sell"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum TradeType {
        #[serde(rename = "buy")]
        Buy,
        #[serde(rename = "sell")]
        Sell,
    }
    impl ::std::convert::From<&Self> for TradeType {
        fn from(value: &TradeType) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for TradeType {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::Buy => f.write_str("buy"),
                Self::Sell => f.write_str("sell"),
            }
        }
    }
    impl ::std::str::FromStr for TradeType {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "buy" => Ok(Self::Buy),
                "sell" => Ok(Self::Sell),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for TradeType {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String> for TradeType {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for TradeType {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    ///`TraderGainersLosersItemDto`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "address",
    ///    "chain",
    ///    "pnl",
    ///    "tradeCount",
    ///    "volume"
    ///  ],
    ///  "properties": {
    ///    "address": {
    ///      "description": "DTO.TRADER.GAINERS_LOSERS.ITEM.ADDRESS",
    ///      "examples": [
    ///        "HLnpSz9h2S4hiLQ43rnSD9XkcUThA7B8hQMKmDaiTLcC"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "chain": {
    ///      "description": "GLOBAL.CHAIN.DESCRIPTION",
    ///      "examples": [
    ///        "sol"
    ///      ],
    ///      "allOf": [
    ///        {
    ///          "$ref": "#/components/schemas/ChainSymbol"
    ///        }
    ///      ]
    ///    },
    ///    "pnl": {
    ///      "description": "DTO.TRADER.GAINERS_LOSERS.ITEM.PNL",
    ///      "examples": [
    ///        "37765184714.25"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "tradeCount": {
    ///      "description": "DTO.TRADER.GAINERS_LOSERS.ITEM.TRADE_COUNT",
    ///      "examples": [
    ///        "31904567"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "volume": {
    ///      "description": "DTO.TRADER.GAINERS_LOSERS.ITEM.VOLUME",
    ///      "examples": [
    ///        "641087465734.79"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct TraderGainersLosersItemDto {
        ///DTO.TRADER.GAINERS_LOSERS.ITEM.ADDRESS
        pub address: ::std::string::String,
        ///GLOBAL.CHAIN.DESCRIPTION
        pub chain: ChainSymbol,
        ///DTO.TRADER.GAINERS_LOSERS.ITEM.PNL
        pub pnl: ::std::string::String,
        ///DTO.TRADER.GAINERS_LOSERS.ITEM.TRADE_COUNT
        #[serde(rename = "tradeCount")]
        pub trade_count: ::std::string::String,
        ///DTO.TRADER.GAINERS_LOSERS.ITEM.VOLUME
        pub volume: ::std::string::String,
    }
    impl ::std::convert::From<&TraderGainersLosersItemDto>
    for TraderGainersLosersItemDto {
        fn from(value: &TraderGainersLosersItemDto) -> Self {
            value.clone()
        }
    }
    impl TraderGainersLosersItemDto {
        pub fn builder() -> builder::TraderGainersLosersItemDto {
            Default::default()
        }
    }
    ///`TraderGainersLosersPage`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "data"
    ///  ],
    ///  "properties": {
    ///    "data": {
    ///      "description": "DTO.TRADE.GAINERS_LOSERS.PAGE.DATA",
    ///      "type": "array",
    ///      "items": {
    ///        "$ref": "#/components/schemas/TraderGainersLosersItemDTO"
    ///      }
    ///    },
    ///    "endCursor": {
    ///      "description": "DTO.PAGE.END_CURSOR",
    ///      "type": "string"
    ///    },
    ///    "hasNext": {
    ///      "description": "DTO.PAGE.HAS_NEXT",
    ///      "default": false,
    ///      "type": "boolean"
    ///    },
    ///    "hasPrev": {
    ///      "description": "DTO.PAGE.HAS_PREV",
    ///      "default": false,
    ///      "type": "boolean"
    ///    },
    ///    "startCursor": {
    ///      "description": "DTO.PAGE.START_CURSOR",
    ///      "type": "string"
    ///    },
    ///    "total": {
    ///      "description": "DTO.PAGE.TOTAL",
    ///      "default": 0,
    ///      "type": "integer",
    ///      "format": "int64"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct TraderGainersLosersPage {
        ///DTO.TRADE.GAINERS_LOSERS.PAGE.DATA
        pub data: ::std::vec::Vec<TraderGainersLosersItemDto>,
        ///DTO.PAGE.END_CURSOR
        #[serde(
            rename = "endCursor",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub end_cursor: ::std::option::Option<::std::string::String>,
        ///DTO.PAGE.HAS_NEXT
        #[serde(rename = "hasNext", default)]
        pub has_next: bool,
        ///DTO.PAGE.HAS_PREV
        #[serde(rename = "hasPrev", default)]
        pub has_prev: bool,
        ///DTO.PAGE.START_CURSOR
        #[serde(
            rename = "startCursor",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub start_cursor: ::std::option::Option<::std::string::String>,
        ///DTO.PAGE.TOTAL
        #[serde(default)]
        pub total: i64,
    }
    impl ::std::convert::From<&TraderGainersLosersPage> for TraderGainersLosersPage {
        fn from(value: &TraderGainersLosersPage) -> Self {
            value.clone()
        }
    }
    impl TraderGainersLosersPage {
        pub fn builder() -> builder::TraderGainersLosersPage {
            Default::default()
        }
    }
    ///`TraderPnlResolution`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "string",
    ///  "enum": [
    ///    "1d",
    ///    "7d",
    ///    "30d"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum TraderPnlResolution {
        #[serde(rename = "1d")]
        X1d,
        #[serde(rename = "7d")]
        X7d,
        #[serde(rename = "30d")]
        X30d,
    }
    impl ::std::convert::From<&Self> for TraderPnlResolution {
        fn from(value: &TraderPnlResolution) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for TraderPnlResolution {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::X1d => f.write_str("1d"),
                Self::X7d => f.write_str("7d"),
                Self::X30d => f.write_str("30d"),
            }
        }
    }
    impl ::std::str::FromStr for TraderPnlResolution {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "1d" => Ok(Self::X1d),
                "7d" => Ok(Self::X7d),
                "30d" => Ok(Self::X30d),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for TraderPnlResolution {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String> for TraderPnlResolution {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String> for TraderPnlResolution {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    ///`TransactionHistoryItemDto`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "blockNumber",
    ///    "blockTime",
    ///    "dappProgram",
    ///    "decimals",
    ///    "fee",
    ///    "from",
    ///    "fromTokenAccount",
    ///    "fromUserAccount",
    ///    "mainAction",
    ///    "name",
    ///    "outerDappProgram",
    ///    "status",
    ///    "symbol",
    ///    "to",
    ///    "toTokenAccount",
    ///    "toUserAccount",
    ///    "tokenAddress",
    ///    "tokenAmount",
    ///    "tokenAmountInUsd",
    ///    "tokenPriceInUsd",
    ///    "txHash"
    ///  ],
    ///  "properties": {
    ///    "blockNumber": {
    ///      "description": "DTO.WALLET.TX_HISTORY.BLOCK_NUMBER",
    ///      "examples": [
    ///        376227481
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "blockTime": {
    ///      "description": "DTO.WALLET.TX_HISTORY.BLOCK_TIME",
    ///      "examples": [
    ///        1738713335000
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "dappProgram": {
    ///      "description": "DTO.WALLET.TX_HISTORY.DAPP_PROGRAM",
    ///      "examples": [
    ///        "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "decimals": {
    ///      "description": "DTO.WALLET.TX_HISTORY.DECIMALS",
    ///      "examples": [
    ///        9
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "fee": {
    ///      "description": "DTO.WALLET.TX_HISTORY.FEE",
    ///      "examples": [
    ///        "15100"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "from": {
    ///      "description": "DTO.WALLET.TX_HISTORY.FROM",
    ///      "examples": [
    ///        "FrxXcJ1uUHa9A5jxgNFBxT4bHBnFVQZbxJa2Je3gjotP"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "fromTokenAccount": {
    ///      "description": "DTO.WALLET.TX_HISTORY.FROM_TOKEN_ACCOUNT",
    ///      "examples": [
    ///        "94Vaes4rvAWkAav1uDS27Y88rC7ZRAyFfc6RCX913CLj"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "fromUserAccount": {
    ///      "description": "DTO.WALLET.TX_HISTORY.FROM_USER_ACCOUNT",
    ///      "examples": [
    ///        "FrxXcJ1uUHa9A5jxgNFBxT4bHBnFVQZbxJa2Je3gjotP"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "logoUri": {
    ///      "description": "DTO.WALLET.TX_HISTORY.LOGO_URI",
    ///      "examples": [
    ///        "https://..."
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "mainAction": {
    ///      "description": "DTO.WALLET.TX_HISTORY.MAIN_ACTION",
    ///      "examples": [
    ///        "send"
    ///      ],
    ///      "type": "string",
    ///      "enum": [
    ///        "send",
    ///        "receive"
    ///      ]
    ///    },
    ///    "name": {
    ///      "description": "DTO.WALLET.TX_HISTORY.NAME",
    ///      "examples": [
    ///        "Wrapped SOL"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "outerDappProgram": {
    ///      "description": "DTO.WALLET.TX_HISTORY.OUTER_DAPP_PROGRAM",
    ///      "examples": [
    ///        "cpamdpZCGKUy5JxQXB4dcpGPiikHawvSWAd6mEn1sGG"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "status": {
    ///      "description": "DTO.WALLET.TX_HISTORY.STATUS",
    ///      "examples": [
    ///        "SUCCEEDED"
    ///      ],
    ///      "type": "string",
    ///      "enum": [
    ///        "UNKNOWN",
    ///        "SUCCEEDED",
    ///        "FAILED"
    ///      ]
    ///    },
    ///    "symbol": {
    ///      "description": "DTO.WALLET.TX_HISTORY.SYMBOL",
    ///      "examples": [
    ///        "SOL"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "to": {
    ///      "description": "DTO.WALLET.TX_HISTORY.TO",
    ///      "examples": [
    ///        "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "toTokenAccount": {
    ///      "description": "DTO.WALLET.TX_HISTORY.TO_TOKEN_ACCOUNT",
    ///      "examples": [
    ///        "FnHnRAigUUm4aU3F8jPksG8rua8yZNBw3TNQddaTmESR"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "toUserAccount": {
    ///      "description": "DTO.WALLET.TX_HISTORY.TO_USER_ACCOUNT",
    ///      "examples": [
    ///        "HLnpSz9h2S4hiLQ43rnSD9XkcUThA7B8hQMKmDaiTLcC"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "tokenAddress": {
    ///      "description": "DTO.WALLET.TX_HISTORY.TOKEN_ADDRESS",
    ///      "examples": [
    ///        "So11111111111111111111111111111111111111112"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "tokenAmount": {
    ///      "description": "DTO.WALLET.TX_HISTORY.TOKEN_AMOUNT",
    ///      "examples": [
    ///        "0.036416"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "tokenAmountInUsd": {
    ///      "description": "DTO.WALLET.TX_HISTORY.TOKEN_AMOUNT_IN_USD",
    ///      "examples": [
    ///        "3.349067"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "tokenPriceInUsd": {
    ///      "description": "DTO.WALLET.TX_HISTORY.TOKEN_PRICE_IN_USD",
    ///      "examples": [
    ///        "91.9669269600"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "txHash": {
    ///      "description": "DTO.WALLET.TX_HISTORY.TX_HASH",
    ///      "examples": [
    ///        "4tEHfECrLJm8N7dNCfQSjhLG7LqdMuZhzBhRy7VRhjCt..."
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct TransactionHistoryItemDto {
        ///DTO.WALLET.TX_HISTORY.BLOCK_NUMBER
        #[serde(rename = "blockNumber")]
        pub block_number: i64,
        ///DTO.WALLET.TX_HISTORY.BLOCK_TIME
        #[serde(rename = "blockTime")]
        pub block_time: i64,
        ///DTO.WALLET.TX_HISTORY.DAPP_PROGRAM
        #[serde(rename = "dappProgram")]
        pub dapp_program: ::std::string::String,
        ///DTO.WALLET.TX_HISTORY.DECIMALS
        pub decimals: i64,
        ///DTO.WALLET.TX_HISTORY.FEE
        pub fee: ::std::string::String,
        ///DTO.WALLET.TX_HISTORY.FROM
        pub from: ::std::string::String,
        ///DTO.WALLET.TX_HISTORY.FROM_TOKEN_ACCOUNT
        #[serde(rename = "fromTokenAccount")]
        pub from_token_account: ::std::string::String,
        ///DTO.WALLET.TX_HISTORY.FROM_USER_ACCOUNT
        #[serde(rename = "fromUserAccount")]
        pub from_user_account: ::std::string::String,
        ///DTO.WALLET.TX_HISTORY.LOGO_URI
        #[serde(
            rename = "logoUri",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub logo_uri: ::std::option::Option<::std::string::String>,
        ///DTO.WALLET.TX_HISTORY.MAIN_ACTION
        #[serde(rename = "mainAction")]
        pub main_action: TransactionHistoryItemDtoMainAction,
        ///DTO.WALLET.TX_HISTORY.NAME
        pub name: ::std::string::String,
        ///DTO.WALLET.TX_HISTORY.OUTER_DAPP_PROGRAM
        #[serde(rename = "outerDappProgram")]
        pub outer_dapp_program: ::std::string::String,
        ///DTO.WALLET.TX_HISTORY.STATUS
        pub status: TransactionHistoryItemDtoStatus,
        ///DTO.WALLET.TX_HISTORY.SYMBOL
        pub symbol: ::std::string::String,
        ///DTO.WALLET.TX_HISTORY.TO
        pub to: ::std::string::String,
        ///DTO.WALLET.TX_HISTORY.TO_TOKEN_ACCOUNT
        #[serde(rename = "toTokenAccount")]
        pub to_token_account: ::std::string::String,
        ///DTO.WALLET.TX_HISTORY.TO_USER_ACCOUNT
        #[serde(rename = "toUserAccount")]
        pub to_user_account: ::std::string::String,
        ///DTO.WALLET.TX_HISTORY.TOKEN_ADDRESS
        #[serde(rename = "tokenAddress")]
        pub token_address: ::std::string::String,
        ///DTO.WALLET.TX_HISTORY.TOKEN_AMOUNT
        #[serde(rename = "tokenAmount")]
        pub token_amount: ::std::string::String,
        ///DTO.WALLET.TX_HISTORY.TOKEN_AMOUNT_IN_USD
        #[serde(rename = "tokenAmountInUsd")]
        pub token_amount_in_usd: ::std::string::String,
        ///DTO.WALLET.TX_HISTORY.TOKEN_PRICE_IN_USD
        #[serde(rename = "tokenPriceInUsd")]
        pub token_price_in_usd: ::std::string::String,
        ///DTO.WALLET.TX_HISTORY.TX_HASH
        #[serde(rename = "txHash")]
        pub tx_hash: ::std::string::String,
    }
    impl ::std::convert::From<&TransactionHistoryItemDto> for TransactionHistoryItemDto {
        fn from(value: &TransactionHistoryItemDto) -> Self {
            value.clone()
        }
    }
    impl TransactionHistoryItemDto {
        pub fn builder() -> builder::TransactionHistoryItemDto {
            Default::default()
        }
    }
    ///DTO.WALLET.TX_HISTORY.MAIN_ACTION
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "DTO.WALLET.TX_HISTORY.MAIN_ACTION",
    ///  "examples": [
    ///    "send"
    ///  ],
    ///  "type": "string",
    ///  "enum": [
    ///    "send",
    ///    "receive"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum TransactionHistoryItemDtoMainAction {
        #[serde(rename = "send")]
        Send,
        #[serde(rename = "receive")]
        Receive,
    }
    impl ::std::convert::From<&Self> for TransactionHistoryItemDtoMainAction {
        fn from(value: &TransactionHistoryItemDtoMainAction) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for TransactionHistoryItemDtoMainAction {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::Send => f.write_str("send"),
                Self::Receive => f.write_str("receive"),
            }
        }
    }
    impl ::std::str::FromStr for TransactionHistoryItemDtoMainAction {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "send" => Ok(Self::Send),
                "receive" => Ok(Self::Receive),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for TransactionHistoryItemDtoMainAction {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String>
    for TransactionHistoryItemDtoMainAction {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String>
    for TransactionHistoryItemDtoMainAction {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    ///DTO.WALLET.TX_HISTORY.STATUS
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "DTO.WALLET.TX_HISTORY.STATUS",
    ///  "examples": [
    ///    "SUCCEEDED"
    ///  ],
    ///  "type": "string",
    ///  "enum": [
    ///    "UNKNOWN",
    ///    "SUCCEEDED",
    ///    "FAILED"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum TransactionHistoryItemDtoStatus {
        #[serde(rename = "UNKNOWN")]
        Unknown,
        #[serde(rename = "SUCCEEDED")]
        Succeeded,
        #[serde(rename = "FAILED")]
        Failed,
    }
    impl ::std::convert::From<&Self> for TransactionHistoryItemDtoStatus {
        fn from(value: &TransactionHistoryItemDtoStatus) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for TransactionHistoryItemDtoStatus {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::Unknown => f.write_str("UNKNOWN"),
                Self::Succeeded => f.write_str("SUCCEEDED"),
                Self::Failed => f.write_str("FAILED"),
            }
        }
    }
    impl ::std::str::FromStr for TransactionHistoryItemDtoStatus {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "UNKNOWN" => Ok(Self::Unknown),
                "SUCCEEDED" => Ok(Self::Succeeded),
                "FAILED" => Ok(Self::Failed),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for TransactionHistoryItemDtoStatus {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String>
    for TransactionHistoryItemDtoStatus {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String>
    for TransactionHistoryItemDtoStatus {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    ///`TransactionHistoryPage`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "data"
    ///  ],
    ///  "properties": {
    ///    "data": {
    ///      "description": "DTO.PAGE.DATA",
    ///      "type": "array",
    ///      "items": {
    ///        "$ref": "#/components/schemas/TransactionHistoryItemDTO"
    ///      }
    ///    },
    ///    "endCursor": {
    ///      "description": "DTO.PAGE.END_CURSOR",
    ///      "type": "string"
    ///    },
    ///    "hasNext": {
    ///      "description": "DTO.PAGE.HAS_NEXT",
    ///      "default": false,
    ///      "type": "boolean"
    ///    },
    ///    "hasPrev": {
    ///      "description": "DTO.PAGE.HAS_PREV",
    ///      "default": false,
    ///      "type": "boolean"
    ///    },
    ///    "startCursor": {
    ///      "description": "DTO.PAGE.START_CURSOR",
    ///      "type": "string"
    ///    },
    ///    "total": {
    ///      "description": "DTO.PAGE.TOTAL",
    ///      "default": 0,
    ///      "type": "integer",
    ///      "format": "int64"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct TransactionHistoryPage {
        ///DTO.PAGE.DATA
        pub data: ::std::vec::Vec<TransactionHistoryItemDto>,
        ///DTO.PAGE.END_CURSOR
        #[serde(
            rename = "endCursor",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub end_cursor: ::std::option::Option<::std::string::String>,
        ///DTO.PAGE.HAS_NEXT
        #[serde(rename = "hasNext", default)]
        pub has_next: bool,
        ///DTO.PAGE.HAS_PREV
        #[serde(rename = "hasPrev", default)]
        pub has_prev: bool,
        ///DTO.PAGE.START_CURSOR
        #[serde(
            rename = "startCursor",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub start_cursor: ::std::option::Option<::std::string::String>,
        ///DTO.PAGE.TOTAL
        #[serde(default)]
        pub total: i64,
    }
    impl ::std::convert::From<&TransactionHistoryPage> for TransactionHistoryPage {
        fn from(value: &TransactionHistoryPage) -> Self {
            value.clone()
        }
    }
    impl TransactionHistoryPage {
        pub fn builder() -> builder::TransactionHistoryPage {
            Default::default()
        }
    }
    ///`TransferAlertsResponseDto`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "alerts"
    ///  ],
    ///  "properties": {
    ///    "alerts": {
    ///      "description": "DTO.KYT.TRANSFER_ALERTS_RESPONSE.ALERTS",
    ///      "type": "array",
    ///      "items": {
    ///        "$ref": "#/components/schemas/AlertDetail"
    ///      }
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct TransferAlertsResponseDto {
        ///DTO.KYT.TRANSFER_ALERTS_RESPONSE.ALERTS
        pub alerts: ::std::vec::Vec<AlertDetail>,
    }
    impl ::std::convert::From<&TransferAlertsResponseDto> for TransferAlertsResponseDto {
        fn from(value: &TransferAlertsResponseDto) -> Self {
            value.clone()
        }
    }
    impl TransferAlertsResponseDto {
        pub fn builder() -> builder::TransferAlertsResponseDto {
            Default::default()
        }
    }
    ///`TransferBaseResponseDto`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "asset",
    ///    "assetAmount",
    ///    "assetId",
    ///    "externalId",
    ///    "idx",
    ///    "memo",
    ///    "network",
    ///    "outputAddress",
    ///    "timestamp",
    ///    "transferReference",
    ///    "tx",
    ///    "updatedAt",
    ///    "usdAmount"
    ///  ],
    ///  "properties": {
    ///    "asset": {
    ///      "description": "DTO.KYT.TRANSFER_BASE_RESPONSE.ASSET",
    ///      "examples": [
    ///        "BTC"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "assetAmount": {
    ///      "description": "DTO.KYT.TRANSFER_BASE_RESPONSE.ASSET_AMOUNT",
    ///      "examples": [
    ///        "11.35113454"
    ///      ],
    ///      "type": [
    ///        "string",
    ///        "null"
    ///      ]
    ///    },
    ///    "assetId": {
    ///      "description": "DTO.KYT.TRANSFER_BASE_RESPONSE.ASSET_ID",
    ///      "type": [
    ///        "string",
    ///        "null"
    ///      ]
    ///    },
    ///    "externalId": {
    ///      "description": "DTO.KYT.TRANSFER_BASE_RESPONSE.EXTERNAL_ID",
    ///      "examples": [
    ///        "393905a7-bb96-394b-9e20-3645298c1079"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "idx": {
    ///      "description": "DTO.KYT.TRANSFER_BASE_RESPONSE.IDX",
    ///      "examples": [
    ///        2
    ///      ],
    ///      "type": [
    ///        "integer",
    ///        "null"
    ///      ],
    ///      "format": "int64"
    ///    },
    ///    "memo": {
    ///      "description": "DTO.KYT.TRANSFER_BASE_RESPONSE.MEMO",
    ///      "type": [
    ///        "string",
    ///        "null"
    ///      ]
    ///    },
    ///    "network": {
    ///      "description": "DTO.KYT.TRANSFER_BASE_RESPONSE.NETWORK",
    ///      "examples": [
    ///        "BITCOIN"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "outputAddress": {
    ///      "description": "DTO.KYT.TRANSFER_BASE_RESPONSE.OUTPUT_ADDRESS",
    ///      "examples": [
    ///        "17A16QmavnUfCW11DAApiJxp7ARnxN5pGX"
    ///      ],
    ///      "type": [
    ///        "string",
    ///        "null"
    ///      ]
    ///    },
    ///    "timestamp": {
    ///      "description": "DTO.KYT.TRANSFER_BASE_RESPONSE.TIMESTAMP",
    ///      "examples": [
    ///        "2021-11-16T18:33:33.000+00:00"
    ///      ],
    ///      "type": [
    ///        "string",
    ///        "null"
    ///      ]
    ///    },
    ///    "transferReference": {
    ///      "description": "DTO.KYT.TRANSFER_BASE_RESPONSE.TRANSFER_REFERENCE",
    ///      "examples": [
    ///        "9f318afbad2a183f97750bc51a75b582ad8f9e9cbfb50401148857ca27cde10c:17A16QmavnUfCW11DAApiJxp7ARnxN5pGX"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "tx": {
    ///      "description": "DTO.KYT.TRANSFER_BASE_RESPONSE.TX",
    ///      "examples": [
    ///        "9f318afbad2a183f97750bc51a75b582ad8f9e9cbfb50401148857ca27cde10c"
    ///      ],
    ///      "type": [
    ///        "string",
    ///        "null"
    ///      ]
    ///    },
    ///    "updatedAt": {
    ///      "description": "DTO.KYT.TRANSFER_BASE_RESPONSE.UPDATED_AT",
    ///      "examples": [
    ///        "2022-03-16T16:17:19.613215"
    ///      ],
    ///      "type": [
    ///        "string",
    ///        "null"
    ///      ]
    ///    },
    ///    "usdAmount": {
    ///      "description": "DTO.KYT.TRANSFER_BASE_RESPONSE.USD_AMOUNT",
    ///      "examples": [
    ///        "722099.75"
    ///      ],
    ///      "type": [
    ///        "string",
    ///        "null"
    ///      ]
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct TransferBaseResponseDto {
        ///DTO.KYT.TRANSFER_BASE_RESPONSE.ASSET
        pub asset: ::std::string::String,
        ///DTO.KYT.TRANSFER_BASE_RESPONSE.ASSET_AMOUNT
        #[serde(rename = "assetAmount")]
        pub asset_amount: ::std::option::Option<::std::string::String>,
        ///DTO.KYT.TRANSFER_BASE_RESPONSE.ASSET_ID
        #[serde(rename = "assetId")]
        pub asset_id: ::std::option::Option<::std::string::String>,
        ///DTO.KYT.TRANSFER_BASE_RESPONSE.EXTERNAL_ID
        #[serde(rename = "externalId")]
        pub external_id: ::std::string::String,
        ///DTO.KYT.TRANSFER_BASE_RESPONSE.IDX
        pub idx: ::std::option::Option<i64>,
        ///DTO.KYT.TRANSFER_BASE_RESPONSE.MEMO
        pub memo: ::std::option::Option<::std::string::String>,
        ///DTO.KYT.TRANSFER_BASE_RESPONSE.NETWORK
        pub network: ::std::string::String,
        ///DTO.KYT.TRANSFER_BASE_RESPONSE.OUTPUT_ADDRESS
        #[serde(rename = "outputAddress")]
        pub output_address: ::std::option::Option<::std::string::String>,
        ///DTO.KYT.TRANSFER_BASE_RESPONSE.TIMESTAMP
        pub timestamp: ::std::option::Option<::std::string::String>,
        ///DTO.KYT.TRANSFER_BASE_RESPONSE.TRANSFER_REFERENCE
        #[serde(rename = "transferReference")]
        pub transfer_reference: ::std::string::String,
        ///DTO.KYT.TRANSFER_BASE_RESPONSE.TX
        pub tx: ::std::option::Option<::std::string::String>,
        ///DTO.KYT.TRANSFER_BASE_RESPONSE.UPDATED_AT
        #[serde(rename = "updatedAt")]
        pub updated_at: ::std::option::Option<::std::string::String>,
        ///DTO.KYT.TRANSFER_BASE_RESPONSE.USD_AMOUNT
        #[serde(rename = "usdAmount")]
        pub usd_amount: ::std::option::Option<::std::string::String>,
    }
    impl ::std::convert::From<&TransferBaseResponseDto> for TransferBaseResponseDto {
        fn from(value: &TransferBaseResponseDto) -> Self {
            value.clone()
        }
    }
    impl TransferBaseResponseDto {
        pub fn builder() -> builder::TransferBaseResponseDto {
            Default::default()
        }
    }
    ///`TransferDirectExposureResponseDto`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "direct"
    ///  ],
    ///  "properties": {
    ///    "direct": {
    ///      "description": "DTO.KYT.TRANSFER_DIRECT_EXPOSURE_RESPONSE.DIRECT",
    ///      "allOf": [
    ///        {
    ///          "$ref": "#/components/schemas/DirectExposureDetail"
    ///        }
    ///      ]
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct TransferDirectExposureResponseDto {
        ///DTO.KYT.TRANSFER_DIRECT_EXPOSURE_RESPONSE.DIRECT
        pub direct: DirectExposureDetail,
    }
    impl ::std::convert::From<&TransferDirectExposureResponseDto>
    for TransferDirectExposureResponseDto {
        fn from(value: &TransferDirectExposureResponseDto) -> Self {
            value.clone()
        }
    }
    impl TransferDirectExposureResponseDto {
        pub fn builder() -> builder::TransferDirectExposureResponseDto {
            Default::default()
        }
    }
    ///`TransferNetworkIdentificationsResponseDto`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "count",
    ///    "networkIdentificationOrgs"
    ///  ],
    ///  "properties": {
    ///    "count": {
    ///      "description": "DTO.KYT.TRANSFER_NETWORK_IDENTIFICATIONS_RESPONSE.COUNT",
    ///      "examples": [
    ///        1
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "networkIdentificationOrgs": {
    ///      "description": "DTO.KYT.TRANSFER_NETWORK_IDENTIFICATIONS_RESPONSE.NETWORK_IDENTIFICATION_ORGS",
    ///      "type": "array",
    ///      "items": {
    ///        "$ref": "#/components/schemas/NetworkIdentificationOrg"
    ///      }
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct TransferNetworkIdentificationsResponseDto {
        ///DTO.KYT.TRANSFER_NETWORK_IDENTIFICATIONS_RESPONSE.COUNT
        pub count: i64,
        ///DTO.KYT.TRANSFER_NETWORK_IDENTIFICATIONS_RESPONSE.NETWORK_IDENTIFICATION_ORGS
        #[serde(rename = "networkIdentificationOrgs")]
        pub network_identification_orgs: ::std::vec::Vec<NetworkIdentificationOrg>,
    }
    impl ::std::convert::From<&TransferNetworkIdentificationsResponseDto>
    for TransferNetworkIdentificationsResponseDto {
        fn from(value: &TransferNetworkIdentificationsResponseDto) -> Self {
            value.clone()
        }
    }
    impl TransferNetworkIdentificationsResponseDto {
        pub fn builder() -> builder::TransferNetworkIdentificationsResponseDto {
            Default::default()
        }
    }
    ///`UpdateEndpointInput`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "properties": {
    ///    "channels": {
    ///      "description": "DTO.ENDPOINT.CHANNELS",
    ///      "examples": [
    ///        [
    ///          "sol.token.migrated",
    ///          "sol.token.created"
    ///        ]
    ///      ],
    ///      "type": "array",
    ///      "items": {
    ///        "type": "string",
    ///        "enum": [
    ///          "sol.token.migrated",
    ///          "sol.token.created"
    ///        ]
    ///      }
    ///    },
    ///    "description": {
    ///      "description": "DTO.ENDPOINT.DESCRIPTION",
    ///      "examples": [
    ///        "Webhook description"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "disabled": {
    ///      "description": "DTO.ENDPOINT.DISABLED",
    ///      "default": false,
    ///      "type": "boolean"
    ///    },
    ///    "endpointId": {
    ///      "description": "DTO.ENDPOINT.ENDPOINT_ID",
    ///      "examples": [
    ///        "123"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "filter": {
    ///      "description": "DTO.ENDPOINT.FILTER",
    ///      "type": "string"
    ///    },
    ///    "filterTypes": {
    ///      "description": "DTO.ENDPOINT.FILTER_TYPES",
    ///      "type": "array",
    ///      "items": {
    ///        "type": "string"
    ///      }
    ///    },
    ///    "metadata": {
    ///      "description": "DTO.ENDPOINT.METADATA",
    ///      "examples": [
    ///        {
    ///          "key": "value"
    ///        }
    ///      ],
    ///      "type": "object"
    ///    },
    ///    "rateLimit": {
    ///      "description": "DTO.ENDPOINT.RATE_LIMIT",
    ///      "examples": [
    ///        1000
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "url": {
    ///      "description": "DTO.ENDPOINT.URL",
    ///      "examples": [
    ///        "https://example.com"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct UpdateEndpointInput {
        ///DTO.ENDPOINT.CHANNELS
        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
        pub channels: ::std::vec::Vec<UpdateEndpointInputChannelsItem>,
        ///DTO.ENDPOINT.DESCRIPTION
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub description: ::std::option::Option<::std::string::String>,
        ///DTO.ENDPOINT.DISABLED
        #[serde(default)]
        pub disabled: bool,
        ///DTO.ENDPOINT.ENDPOINT_ID
        #[serde(
            rename = "endpointId",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub endpoint_id: ::std::option::Option<::std::string::String>,
        ///DTO.ENDPOINT.FILTER
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub filter: ::std::option::Option<::std::string::String>,
        ///DTO.ENDPOINT.FILTER_TYPES
        #[serde(
            rename = "filterTypes",
            default,
            skip_serializing_if = "::std::vec::Vec::is_empty"
        )]
        pub filter_types: ::std::vec::Vec<::std::string::String>,
        ///DTO.ENDPOINT.METADATA
        #[serde(default, skip_serializing_if = "::serde_json::Map::is_empty")]
        pub metadata: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
        ///DTO.ENDPOINT.RATE_LIMIT
        #[serde(
            rename = "rateLimit",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub rate_limit: ::std::option::Option<i64>,
        ///DTO.ENDPOINT.URL
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub url: ::std::option::Option<::std::string::String>,
    }
    impl ::std::convert::From<&UpdateEndpointInput> for UpdateEndpointInput {
        fn from(value: &UpdateEndpointInput) -> Self {
            value.clone()
        }
    }
    impl ::std::default::Default for UpdateEndpointInput {
        fn default() -> Self {
            Self {
                channels: Default::default(),
                description: Default::default(),
                disabled: Default::default(),
                endpoint_id: Default::default(),
                filter: Default::default(),
                filter_types: Default::default(),
                metadata: Default::default(),
                rate_limit: Default::default(),
                url: Default::default(),
            }
        }
    }
    impl UpdateEndpointInput {
        pub fn builder() -> builder::UpdateEndpointInput {
            Default::default()
        }
    }
    ///`UpdateEndpointInputChannelsItem`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "string",
    ///  "enum": [
    ///    "sol.token.migrated",
    ///    "sol.token.created"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum UpdateEndpointInputChannelsItem {
        #[serde(rename = "sol.token.migrated")]
        SolTokenMigrated,
        #[serde(rename = "sol.token.created")]
        SolTokenCreated,
    }
    impl ::std::convert::From<&Self> for UpdateEndpointInputChannelsItem {
        fn from(value: &UpdateEndpointInputChannelsItem) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for UpdateEndpointInputChannelsItem {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::SolTokenMigrated => f.write_str("sol.token.migrated"),
                Self::SolTokenCreated => f.write_str("sol.token.created"),
            }
        }
    }
    impl ::std::str::FromStr for UpdateEndpointInputChannelsItem {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "sol.token.migrated" => Ok(Self::SolTokenMigrated),
                "sol.token.created" => Ok(Self::SolTokenCreated),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for UpdateEndpointInputChannelsItem {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String>
    for UpdateEndpointInputChannelsItem {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String>
    for UpdateEndpointInputChannelsItem {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    ///`WalletFirstTxDto`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "wallets"
    ///  ],
    ///  "properties": {
    ///    "wallets": {
    ///      "description": "DTO.WALLET.FIRST_TX.TX_HASH",
    ///      "examples": [
    ///        {
    ///          "3bovD5jCRn7eG64jZqyEz6Zbx92mHixZSTRrWLy1Sirx": {
    ///            "balanceChange": "0",
    ///            "blockNumber": 398645949,
    ///            "blockTime": 1717292678000,
    ///            "decimals": 9,
    ///            "tokenAddress": "11111111111111111111111111111111",
    ///            "txHash": "5rG9igZk95gbS8ZG66upvRfbcaaDpokQYg4ny3WQ3DrA..."
    ///          }
    ///        }
    ///      ],
    ///      "type": "object",
    ///      "additionalProperties": {
    ///        "$ref": "#/components/schemas/WalletFirstTxItemDTO"
    ///      }
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct WalletFirstTxDto {
        ///DTO.WALLET.FIRST_TX.TX_HASH
        pub wallets: ::std::collections::HashMap<
            ::std::string::String,
            WalletFirstTxItemDto,
        >,
    }
    impl ::std::convert::From<&WalletFirstTxDto> for WalletFirstTxDto {
        fn from(value: &WalletFirstTxDto) -> Self {
            value.clone()
        }
    }
    impl WalletFirstTxDto {
        pub fn builder() -> builder::WalletFirstTxDto {
            Default::default()
        }
    }
    ///`WalletFirstTxItemDto`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "balanceChange",
    ///    "blockNumber",
    ///    "blockTime",
    ///    "decimals",
    ///    "tokenAddress",
    ///    "txHash"
    ///  ],
    ///  "properties": {
    ///    "balanceChange": {
    ///      "description": "DTO.WALLET.FIRST_TX.BALANCE_CHANGE",
    ///      "examples": [
    ///        "0"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "blockNumber": {
    ///      "description": "DTO.WALLET.FIRST_TX.BLOCK_NUMBER",
    ///      "examples": [
    ///        398645949
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "blockTime": {
    ///      "description": "DTO.WALLET.FIRST_TX.BLOCK_TIME",
    ///      "examples": [
    ///        1717292678000
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "decimals": {
    ///      "description": "DTO.WALLET.FIRST_TX.TOKEN_DECIMALS",
    ///      "examples": [
    ///        9
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "tokenAddress": {
    ///      "description": "DTO.WALLET.FIRST_TX.TOKEN_ADDRESS",
    ///      "examples": [
    ///        "11111111111111111111111111111111"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "txHash": {
    ///      "description": "DTO.WALLET.FIRST_TX.TX_HASH",
    ///      "examples": [
    ///        "5rG9igZk95gbS8ZG66upvRfbcaaDpokQYg4ny3WQ3DrA..."
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct WalletFirstTxItemDto {
        ///DTO.WALLET.FIRST_TX.BALANCE_CHANGE
        #[serde(rename = "balanceChange")]
        pub balance_change: ::std::string::String,
        ///DTO.WALLET.FIRST_TX.BLOCK_NUMBER
        #[serde(rename = "blockNumber")]
        pub block_number: i64,
        ///DTO.WALLET.FIRST_TX.BLOCK_TIME
        #[serde(rename = "blockTime")]
        pub block_time: i64,
        ///DTO.WALLET.FIRST_TX.TOKEN_DECIMALS
        pub decimals: i64,
        ///DTO.WALLET.FIRST_TX.TOKEN_ADDRESS
        #[serde(rename = "tokenAddress")]
        pub token_address: ::std::string::String,
        ///DTO.WALLET.FIRST_TX.TX_HASH
        #[serde(rename = "txHash")]
        pub tx_hash: ::std::string::String,
    }
    impl ::std::convert::From<&WalletFirstTxItemDto> for WalletFirstTxItemDto {
        fn from(value: &WalletFirstTxItemDto) -> Self {
            value.clone()
        }
    }
    impl WalletFirstTxItemDto {
        pub fn builder() -> builder::WalletFirstTxItemDto {
            Default::default()
        }
    }
    ///`WalletNetWorthChartDto`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "currentTimestamp",
    ///    "history",
    ///    "pastTimestamp",
    ///    "walletAddress"
    ///  ],
    ///  "properties": {
    ///    "currentTimestamp": {
    ///      "description": "DTO.WALLET.NET_WORTH_CHART.CURRENT_TIMESTAMP",
    ///      "examples": [
    ///        "2025-07-31T23:59:59.000Z"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "history": {
    ///      "description": "DTO.WALLET.NET_WORTH_CHART.HISTORY",
    ///      "type": "array",
    ///      "items": {
    ///        "$ref": "#/components/schemas/WalletNetWorthHistoryItemDTO"
    ///      }
    ///    },
    ///    "pastTimestamp": {
    ///      "description": "DTO.WALLET.NET_WORTH_CHART.PAST_TIMESTAMP",
    ///      "examples": [
    ///        "2025-07-01T23:59:59.000Z"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "walletAddress": {
    ///      "description": "DTO.WALLET.NET_WORTH_CHART.WALLET_ADDRESS",
    ///      "examples": [
    ///        "HV1KXxWFaSeriyFvXyx48FqG9BoFbfinB8njCJonqP7K"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct WalletNetWorthChartDto {
        ///DTO.WALLET.NET_WORTH_CHART.CURRENT_TIMESTAMP
        #[serde(rename = "currentTimestamp")]
        pub current_timestamp: ::std::string::String,
        ///DTO.WALLET.NET_WORTH_CHART.HISTORY
        pub history: ::std::vec::Vec<WalletNetWorthHistoryItemDto>,
        ///DTO.WALLET.NET_WORTH_CHART.PAST_TIMESTAMP
        #[serde(rename = "pastTimestamp")]
        pub past_timestamp: ::std::string::String,
        ///DTO.WALLET.NET_WORTH_CHART.WALLET_ADDRESS
        #[serde(rename = "walletAddress")]
        pub wallet_address: ::std::string::String,
    }
    impl ::std::convert::From<&WalletNetWorthChartDto> for WalletNetWorthChartDto {
        fn from(value: &WalletNetWorthChartDto) -> Self {
            value.clone()
        }
    }
    impl WalletNetWorthChartDto {
        pub fn builder() -> builder::WalletNetWorthChartDto {
            Default::default()
        }
    }
    ///`WalletNetWorthDetailsPage`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "data",
    ///    "netWorth",
    ///    "requestedTimestamp",
    ///    "resolvedTimestamp",
    ///    "walletAddress"
    ///  ],
    ///  "properties": {
    ///    "data": {
    ///      "description": "DTO.PAGE.DATA",
    ///      "type": "array",
    ///      "items": {
    ///        "$ref": "#/components/schemas/WalletNetWorthItemDTO"
    ///      }
    ///    },
    ///    "endCursor": {
    ///      "description": "DTO.PAGE.END_CURSOR",
    ///      "type": "string"
    ///    },
    ///    "hasNext": {
    ///      "description": "DTO.PAGE.HAS_NEXT",
    ///      "default": false,
    ///      "type": "boolean"
    ///    },
    ///    "hasPrev": {
    ///      "description": "DTO.PAGE.HAS_PREV",
    ///      "default": false,
    ///      "type": "boolean"
    ///    },
    ///    "netWorth": {
    ///      "description": "DTO.WALLET.NET_WORTH_DETAILS.NET_WORTH",
    ///      "examples": [
    ///        "11839478.53162622"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "requestedTimestamp": {
    ///      "description": "DTO.WALLET.NET_WORTH_DETAILS.REQUESTED_TIMESTAMP",
    ///      "examples": [
    ///        "2025-07-31T04:50:06.303Z"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "resolvedTimestamp": {
    ///      "description": "DTO.WALLET.NET_WORTH_DETAILS.RESOLVED_TIMESTAMP",
    ///      "examples": [
    ///        "2025-07-31T04:50:06.475Z"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "startCursor": {
    ///      "description": "DTO.PAGE.START_CURSOR",
    ///      "type": "string"
    ///    },
    ///    "total": {
    ///      "description": "DTO.PAGE.TOTAL",
    ///      "default": 0,
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "walletAddress": {
    ///      "description": "DTO.WALLET.NET_WORTH_DETAILS.WALLET_ADDRESS",
    ///      "examples": [
    ///        "HV1KXxWFaSeriyFvXyx48FqG9BoFbfinB8njCJonqP7K"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct WalletNetWorthDetailsPage {
        ///DTO.PAGE.DATA
        pub data: ::std::vec::Vec<WalletNetWorthItemDto>,
        ///DTO.PAGE.END_CURSOR
        #[serde(
            rename = "endCursor",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub end_cursor: ::std::option::Option<::std::string::String>,
        ///DTO.PAGE.HAS_NEXT
        #[serde(rename = "hasNext", default)]
        pub has_next: bool,
        ///DTO.PAGE.HAS_PREV
        #[serde(rename = "hasPrev", default)]
        pub has_prev: bool,
        ///DTO.WALLET.NET_WORTH_DETAILS.NET_WORTH
        #[serde(rename = "netWorth")]
        pub net_worth: ::std::string::String,
        ///DTO.WALLET.NET_WORTH_DETAILS.REQUESTED_TIMESTAMP
        #[serde(rename = "requestedTimestamp")]
        pub requested_timestamp: ::std::string::String,
        ///DTO.WALLET.NET_WORTH_DETAILS.RESOLVED_TIMESTAMP
        #[serde(rename = "resolvedTimestamp")]
        pub resolved_timestamp: ::std::string::String,
        ///DTO.PAGE.START_CURSOR
        #[serde(
            rename = "startCursor",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub start_cursor: ::std::option::Option<::std::string::String>,
        ///DTO.PAGE.TOTAL
        #[serde(default)]
        pub total: i64,
        ///DTO.WALLET.NET_WORTH_DETAILS.WALLET_ADDRESS
        #[serde(rename = "walletAddress")]
        pub wallet_address: ::std::string::String,
    }
    impl ::std::convert::From<&WalletNetWorthDetailsPage> for WalletNetWorthDetailsPage {
        fn from(value: &WalletNetWorthDetailsPage) -> Self {
            value.clone()
        }
    }
    impl WalletNetWorthDetailsPage {
        pub fn builder() -> builder::WalletNetWorthDetailsPage {
            Default::default()
        }
    }
    ///`WalletNetWorthHistoryItemDto`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "netWorth",
    ///    "netWorthChange",
    ///    "netWorthChangePercent",
    ///    "timestamp"
    ///  ],
    ///  "properties": {
    ///    "netWorth": {
    ///      "description": "DTO.WALLET.NET_WORTH_CHART.ITEM.NET_WORTH",
    ///      "examples": [
    ///        "13210463.21"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "netWorthChange": {
    ///      "description": "DTO.WALLET.NET_WORTH_CHART.ITEM.NET_WORTH_CHANGE",
    ///      "examples": [
    ///        "1971274.94"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "netWorthChangePercent": {
    ///      "description": "DTO.WALLET.NET_WORTH_CHART.ITEM.NET_WORTH_CHANGE_PERCENT",
    ///      "examples": [
    ///        "17.54"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "timestamp": {
    ///      "description": "DTO.WALLET.NET_WORTH_CHART.ITEM.TIMESTAMP",
    ///      "examples": [
    ///        "2025-07-30T23:59:59.000Z"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct WalletNetWorthHistoryItemDto {
        ///DTO.WALLET.NET_WORTH_CHART.ITEM.NET_WORTH
        #[serde(rename = "netWorth")]
        pub net_worth: ::std::string::String,
        ///DTO.WALLET.NET_WORTH_CHART.ITEM.NET_WORTH_CHANGE
        #[serde(rename = "netWorthChange")]
        pub net_worth_change: ::std::string::String,
        ///DTO.WALLET.NET_WORTH_CHART.ITEM.NET_WORTH_CHANGE_PERCENT
        #[serde(rename = "netWorthChangePercent")]
        pub net_worth_change_percent: ::std::string::String,
        ///DTO.WALLET.NET_WORTH_CHART.ITEM.TIMESTAMP
        pub timestamp: ::std::string::String,
    }
    impl ::std::convert::From<&WalletNetWorthHistoryItemDto>
    for WalletNetWorthHistoryItemDto {
        fn from(value: &WalletNetWorthHistoryItemDto) -> Self {
            value.clone()
        }
    }
    impl WalletNetWorthHistoryItemDto {
        pub fn builder() -> builder::WalletNetWorthHistoryItemDto {
            Default::default()
        }
    }
    ///`WalletNetWorthItemDto`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "amount",
    ///    "chain",
    ///    "decimals",
    ///    "name",
    ///    "priceInNative",
    ///    "priceInUsd",
    ///    "symbol",
    ///    "tokenAddress",
    ///    "valueInNative",
    ///    "valueInUsd"
    ///  ],
    ///  "properties": {
    ///    "amount": {
    ///      "description": "DTO.WALLET.NET_WORTH.ITEM.AMOUNT",
    ///      "examples": [
    ///        "69"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "chain": {
    ///      "description": "GLOBAL.CHAIN.DESCRIPTION",
    ///      "examples": [
    ///        "sol"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "decimals": {
    ///      "description": "DTO.WALLET.NET_WORTH.ITEM.DECIMALS",
    ///      "examples": [
    ///        6
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "logoUri": {
    ///      "description": "DTO.WALLET.NET_WORTH.ITEM.LOGO_URI",
    ///      "examples": [
    ///        "https://pump.mypinata.cloud/ipfs/QmcCjKS4MMeji11PqnNhqDSXd6gD4iGj1nC6zjyfaekuQZ"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "name": {
    ///      "description": "DTO.WALLET.NET_WORTH.ITEM.NAME",
    ///      "examples": [
    ///        "Smellow"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "priceInNative": {
    ///      "description": "DTO.WALLET.NET_WORTH.ITEM.PRICE_IN_NATIVE",
    ///      "examples": [
    ///        "0.000001855"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "priceInUsd": {
    ///      "description": "DTO.WALLET.NET_WORTH.ITEM.PRICE_IN_USD",
    ///      "examples": [
    ///        "0.00014999198221145974"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "symbol": {
    ///      "description": "DTO.WALLET.NET_WORTH.ITEM.SYMBOL",
    ///      "examples": [
    ///        "SMLO"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "tokenAddress": {
    ///      "description": "DTO.WALLET.NET_WORTH.ITEM.TOKEN_ADDRESS",
    ///      "examples": [
    ///        "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "valueInNative": {
    ///      "description": "DTO.WALLET.NET_WORTH.ITEM.VALUE_IN_NATIVE",
    ///      "examples": [
    ///        "0.000127995"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "valueInUsd": {
    ///      "description": "DTO.WALLET.NET_WORTH.ITEM.VALUE_IN_USD",
    ///      "examples": [
    ///        "0.010349446772590722"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct WalletNetWorthItemDto {
        ///DTO.WALLET.NET_WORTH.ITEM.AMOUNT
        pub amount: ::std::string::String,
        ///GLOBAL.CHAIN.DESCRIPTION
        pub chain: ::std::string::String,
        ///DTO.WALLET.NET_WORTH.ITEM.DECIMALS
        pub decimals: i64,
        ///DTO.WALLET.NET_WORTH.ITEM.LOGO_URI
        #[serde(
            rename = "logoUri",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub logo_uri: ::std::option::Option<::std::string::String>,
        ///DTO.WALLET.NET_WORTH.ITEM.NAME
        pub name: ::std::string::String,
        ///DTO.WALLET.NET_WORTH.ITEM.PRICE_IN_NATIVE
        #[serde(rename = "priceInNative")]
        pub price_in_native: ::std::string::String,
        ///DTO.WALLET.NET_WORTH.ITEM.PRICE_IN_USD
        #[serde(rename = "priceInUsd")]
        pub price_in_usd: ::std::string::String,
        ///DTO.WALLET.NET_WORTH.ITEM.SYMBOL
        pub symbol: ::std::string::String,
        ///DTO.WALLET.NET_WORTH.ITEM.TOKEN_ADDRESS
        #[serde(rename = "tokenAddress")]
        pub token_address: ::std::string::String,
        ///DTO.WALLET.NET_WORTH.ITEM.VALUE_IN_NATIVE
        #[serde(rename = "valueInNative")]
        pub value_in_native: ::std::string::String,
        ///DTO.WALLET.NET_WORTH.ITEM.VALUE_IN_USD
        #[serde(rename = "valueInUsd")]
        pub value_in_usd: ::std::string::String,
    }
    impl ::std::convert::From<&WalletNetWorthItemDto> for WalletNetWorthItemDto {
        fn from(value: &WalletNetWorthItemDto) -> Self {
            value.clone()
        }
    }
    impl WalletNetWorthItemDto {
        pub fn builder() -> builder::WalletNetWorthItemDto {
            Default::default()
        }
    }
    ///`WalletNetWorthPage`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "currentTimestamp",
    ///    "data",
    ///    "totalValueInNative",
    ///    "totalValueInUsd",
    ///    "walletAddress"
    ///  ],
    ///  "properties": {
    ///    "currentTimestamp": {
    ///      "description": "DTO.WALLET.NET_WORTH.CURRENT_TIMESTAMP",
    ///      "examples": [
    ///        "2025-05-19T04:47:19.414Z"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "data": {
    ///      "description": "DTO.PAGE.DATA",
    ///      "type": "array",
    ///      "items": {
    ///        "$ref": "#/components/schemas/WalletNetWorthItemDTO"
    ///      }
    ///    },
    ///    "endCursor": {
    ///      "description": "DTO.PAGE.END_CURSOR",
    ///      "type": "string"
    ///    },
    ///    "hasNext": {
    ///      "description": "DTO.PAGE.HAS_NEXT",
    ///      "default": false,
    ///      "type": "boolean"
    ///    },
    ///    "hasPrev": {
    ///      "description": "DTO.PAGE.HAS_PREV",
    ///      "default": false,
    ///      "type": "boolean"
    ///    },
    ///    "startCursor": {
    ///      "description": "DTO.PAGE.START_CURSOR",
    ///      "type": "string"
    ///    },
    ///    "total": {
    ///      "description": "DTO.PAGE.TOTAL",
    ///      "default": 0,
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "totalValueInNative": {
    ///      "description": "DTO.WALLET.NET_WORTH.TOTAL_VALUE_IN_NATIVE",
    ///      "examples": [
    ///        "0.040382"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "totalValueInUsd": {
    ///      "description": "DTO.WALLET.NET_WORTH.TOTAL_VALUE_IN_USD",
    ///      "examples": [
    ///        "3.369918"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "walletAddress": {
    ///      "description": "DTO.WALLET.NET_WORTH.WALLET_ADDRESS",
    ///      "examples": [
    ///        "8X35rQUK2u9hfn8rMPwwr6ZSEUhbmfDPEapp589XyoM1"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct WalletNetWorthPage {
        ///DTO.WALLET.NET_WORTH.CURRENT_TIMESTAMP
        #[serde(rename = "currentTimestamp")]
        pub current_timestamp: ::std::string::String,
        ///DTO.PAGE.DATA
        pub data: ::std::vec::Vec<WalletNetWorthItemDto>,
        ///DTO.PAGE.END_CURSOR
        #[serde(
            rename = "endCursor",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub end_cursor: ::std::option::Option<::std::string::String>,
        ///DTO.PAGE.HAS_NEXT
        #[serde(rename = "hasNext", default)]
        pub has_next: bool,
        ///DTO.PAGE.HAS_PREV
        #[serde(rename = "hasPrev", default)]
        pub has_prev: bool,
        ///DTO.PAGE.START_CURSOR
        #[serde(
            rename = "startCursor",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub start_cursor: ::std::option::Option<::std::string::String>,
        ///DTO.PAGE.TOTAL
        #[serde(default)]
        pub total: i64,
        ///DTO.WALLET.NET_WORTH.TOTAL_VALUE_IN_NATIVE
        #[serde(rename = "totalValueInNative")]
        pub total_value_in_native: ::std::string::String,
        ///DTO.WALLET.NET_WORTH.TOTAL_VALUE_IN_USD
        #[serde(rename = "totalValueInUsd")]
        pub total_value_in_usd: ::std::string::String,
        ///DTO.WALLET.NET_WORTH.WALLET_ADDRESS
        #[serde(rename = "walletAddress")]
        pub wallet_address: ::std::string::String,
    }
    impl ::std::convert::From<&WalletNetWorthPage> for WalletNetWorthPage {
        fn from(value: &WalletNetWorthPage) -> Self {
            value.clone()
        }
    }
    impl WalletNetWorthPage {
        pub fn builder() -> builder::WalletNetWorthPage {
            Default::default()
        }
    }
    ///`WalletNetWorthSummaryDto`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "currentTimestamp",
    ///    "wallets"
    ///  ],
    ///  "properties": {
    ///    "currentTimestamp": {
    ///      "description": "DTO.WALLET.NET_WORTH_SUMMARY.CURRENT_TIMESTAMP",
    ///      "examples": [
    ///        "2025-10-30T03:33:40.980Z"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "wallets": {
    ///      "description": "DTO.WALLET.NET_WORTH_SUMMARY.WALLETS",
    ///      "examples": [
    ///        {
    ///          "5Q544fKrFoe6tsEbD7S8EmxGTJYAKtTVhAW5Q5pge4j1": {
    ///            "value": "1764819473.530063"
    ///          },
    ///          "WLHv2UAZm6z4KyaaELi5pjdbJh6RESMva1Rnn8pJVVh": {
    ///            "value": "3508619230.707581"
    ///          }
    ///        }
    ///      ],
    ///      "type": "object",
    ///      "additionalProperties": {
    ///        "$ref": "#/components/schemas/WalletNetWorthSummaryValueDTO"
    ///      }
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct WalletNetWorthSummaryDto {
        ///DTO.WALLET.NET_WORTH_SUMMARY.CURRENT_TIMESTAMP
        #[serde(rename = "currentTimestamp")]
        pub current_timestamp: ::std::string::String,
        ///DTO.WALLET.NET_WORTH_SUMMARY.WALLETS
        pub wallets: ::std::collections::HashMap<
            ::std::string::String,
            WalletNetWorthSummaryValueDto,
        >,
    }
    impl ::std::convert::From<&WalletNetWorthSummaryDto> for WalletNetWorthSummaryDto {
        fn from(value: &WalletNetWorthSummaryDto) -> Self {
            value.clone()
        }
    }
    impl WalletNetWorthSummaryDto {
        pub fn builder() -> builder::WalletNetWorthSummaryDto {
            Default::default()
        }
    }
    ///`WalletNetWorthSummaryValueDto`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "value"
    ///  ],
    ///  "properties": {
    ///    "value": {
    ///      "description": "DTO.WALLET.NET_WORTH_SUMMARY.VALUE",
    ///      "examples": [
    ///        "1764819473.530063"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct WalletNetWorthSummaryValueDto {
        ///DTO.WALLET.NET_WORTH_SUMMARY.VALUE
        pub value: ::std::string::String,
    }
    impl ::std::convert::From<&WalletNetWorthSummaryValueDto>
    for WalletNetWorthSummaryValueDto {
        fn from(value: &WalletNetWorthSummaryValueDto) -> Self {
            value.clone()
        }
    }
    impl WalletNetWorthSummaryValueDto {
        pub fn builder() -> builder::WalletNetWorthSummaryValueDto {
            Default::default()
        }
    }
    ///`WalletPnlSummaryDto`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "avgProfitPerTradeInUsd",
    ///    "buyAmountInUsd",
    ///    "buys",
    ///    "losses",
    ///    "realizedProfitInUsd",
    ///    "realizedProfitRatio",
    ///    "resolution",
    ///    "sellAmountInUsd",
    ///    "sells",
    ///    "tokens",
    ///    "totalCostInUsd",
    ///    "totalProfitInUsd",
    ///    "totalProfitRatio",
    ///    "totalTrades",
    ///    "unrealizedProfitInUsd",
    ///    "unrealizedProfitRatio",
    ///    "walletAddress",
    ///    "winRate",
    ///    "wins"
    ///  ],
    ///  "properties": {
    ///    "avgProfitPerTradeInUsd": {
    ///      "description": "DTO.WALLET.PNL_SUMMARY.AVG_PROFIT_PER_TRADE_IN_USD",
    ///      "examples": [
    ///        "402.86"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "buyAmountInUsd": {
    ///      "description": "DTO.WALLET.PNL_SUMMARY.BUY_AMOUNT_IN_USD",
    ///      "examples": [
    ///        "101371192.39"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "buys": {
    ///      "description": "DTO.WALLET.PNL_SUMMARY.BUYS",
    ///      "examples": [
    ///        "1515999"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "losses": {
    ///      "description": "DTO.WALLET.PNL_SUMMARY.LOSSES",
    ///      "examples": [
    ///        "348350"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "realizedProfitInUsd": {
    ///      "description": "DTO.WALLET.PNL_SUMMARY.REALIZED_PROFIT_IN_USD",
    ///      "examples": [
    ///        "802583.91"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "realizedProfitRatio": {
    ///      "description": "DTO.WALLET.PNL_SUMMARY.REALIZED_PROFIT_RATIO",
    ///      "examples": [
    ///        "0.0035521324"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "resolution": {
    ///      "description": "DTO.WALLET.PNL_SUMMARY.RESOLUTION",
    ///      "examples": [
    ///        "1d"
    ///      ],
    ///      "type": "string",
    ///      "enum": [
    ///        "1d",
    ///        "7d",
    ///        "30d",
    ///        "all"
    ///      ]
    ///    },
    ///    "sellAmountInUsd": {
    ///      "description": "DTO.WALLET.PNL_SUMMARY.SELL_AMOUNT_IN_USD",
    ///      "examples": [
    ///        "60369621.10"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "sells": {
    ///      "description": "DTO.WALLET.PNL_SUMMARY.SELLS",
    ///      "examples": [
    ///        "1011994"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "tokens": {
    ///      "description": "DTO.WALLET.PNL_SUMMARY.TOKENS",
    ///      "examples": [
    ///        "15126"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "totalCostInUsd": {
    ///      "description": "DTO.WALLET.PNL_SUMMARY.TOTAL_COST_IN_USD",
    ///      "examples": [
    ///        "225944253.64"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "totalProfitInUsd": {
    ///      "description": "DTO.WALLET.PNL_SUMMARY.TOTAL_PROFIT_IN_USD",
    ///      "examples": [
    ///        "1018427683.08"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "totalProfitRatio": {
    ///      "description": "DTO.WALLET.PNL_SUMMARY.TOTAL_PROFIT_RATIO",
    ///      "examples": [
    ///        "4.5074290081"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "totalTrades": {
    ///      "description": "DTO.WALLET.PNL_SUMMARY.TOTAL_TRADES",
    ///      "examples": [
    ///        "2527993"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "unrealizedProfitInUsd": {
    ///      "description": "DTO.WALLET.PNL_SUMMARY.UNREALIZED_PROFIT_IN_USD",
    ///      "examples": [
    ///        "1017625099.17"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "unrealizedProfitRatio": {
    ///      "description": "DTO.WALLET.PNL_SUMMARY.UNREALIZED_PROFIT_RATIO",
    ///      "examples": [
    ///        "4.5038768756"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "updatedAt": {
    ///      "description": "DTO.WALLET.PNL_SUMMARY.UPDATED_AT",
    ///      "examples": [
    ///        "2026-02-04T11:42:50.000Z"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "walletAddress": {
    ///      "description": "DTO.WALLET.PNL_SUMMARY.WALLET_ADDRESS",
    ///      "examples": [
    ///        "54Pz1e35z9uoFdnxtzjp7xZQoFiofqhdayQWBMN7dsuy"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "winRate": {
    ///      "description": "DTO.WALLET.PNL_SUMMARY.WIN_RATE",
    ///      "examples": [
    ///        "0.5575"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "wins": {
    ///      "description": "DTO.WALLET.PNL_SUMMARY.WINS",
    ///      "examples": [
    ///        "438944"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct WalletPnlSummaryDto {
        ///DTO.WALLET.PNL_SUMMARY.AVG_PROFIT_PER_TRADE_IN_USD
        #[serde(rename = "avgProfitPerTradeInUsd")]
        pub avg_profit_per_trade_in_usd: ::std::string::String,
        ///DTO.WALLET.PNL_SUMMARY.BUY_AMOUNT_IN_USD
        #[serde(rename = "buyAmountInUsd")]
        pub buy_amount_in_usd: ::std::string::String,
        ///DTO.WALLET.PNL_SUMMARY.BUYS
        pub buys: ::std::string::String,
        ///DTO.WALLET.PNL_SUMMARY.LOSSES
        pub losses: ::std::string::String,
        ///DTO.WALLET.PNL_SUMMARY.REALIZED_PROFIT_IN_USD
        #[serde(rename = "realizedProfitInUsd")]
        pub realized_profit_in_usd: ::std::string::String,
        ///DTO.WALLET.PNL_SUMMARY.REALIZED_PROFIT_RATIO
        #[serde(rename = "realizedProfitRatio")]
        pub realized_profit_ratio: ::std::string::String,
        ///DTO.WALLET.PNL_SUMMARY.RESOLUTION
        pub resolution: WalletPnlSummaryDtoResolution,
        ///DTO.WALLET.PNL_SUMMARY.SELL_AMOUNT_IN_USD
        #[serde(rename = "sellAmountInUsd")]
        pub sell_amount_in_usd: ::std::string::String,
        ///DTO.WALLET.PNL_SUMMARY.SELLS
        pub sells: ::std::string::String,
        ///DTO.WALLET.PNL_SUMMARY.TOKENS
        pub tokens: ::std::string::String,
        ///DTO.WALLET.PNL_SUMMARY.TOTAL_COST_IN_USD
        #[serde(rename = "totalCostInUsd")]
        pub total_cost_in_usd: ::std::string::String,
        ///DTO.WALLET.PNL_SUMMARY.TOTAL_PROFIT_IN_USD
        #[serde(rename = "totalProfitInUsd")]
        pub total_profit_in_usd: ::std::string::String,
        ///DTO.WALLET.PNL_SUMMARY.TOTAL_PROFIT_RATIO
        #[serde(rename = "totalProfitRatio")]
        pub total_profit_ratio: ::std::string::String,
        ///DTO.WALLET.PNL_SUMMARY.TOTAL_TRADES
        #[serde(rename = "totalTrades")]
        pub total_trades: ::std::string::String,
        ///DTO.WALLET.PNL_SUMMARY.UNREALIZED_PROFIT_IN_USD
        #[serde(rename = "unrealizedProfitInUsd")]
        pub unrealized_profit_in_usd: ::std::string::String,
        ///DTO.WALLET.PNL_SUMMARY.UNREALIZED_PROFIT_RATIO
        #[serde(rename = "unrealizedProfitRatio")]
        pub unrealized_profit_ratio: ::std::string::String,
        ///DTO.WALLET.PNL_SUMMARY.UPDATED_AT
        #[serde(
            rename = "updatedAt",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub updated_at: ::std::option::Option<::std::string::String>,
        ///DTO.WALLET.PNL_SUMMARY.WALLET_ADDRESS
        #[serde(rename = "walletAddress")]
        pub wallet_address: ::std::string::String,
        ///DTO.WALLET.PNL_SUMMARY.WIN_RATE
        #[serde(rename = "winRate")]
        pub win_rate: ::std::string::String,
        ///DTO.WALLET.PNL_SUMMARY.WINS
        pub wins: ::std::string::String,
    }
    impl ::std::convert::From<&WalletPnlSummaryDto> for WalletPnlSummaryDto {
        fn from(value: &WalletPnlSummaryDto) -> Self {
            value.clone()
        }
    }
    impl WalletPnlSummaryDto {
        pub fn builder() -> builder::WalletPnlSummaryDto {
            Default::default()
        }
    }
    ///DTO.WALLET.PNL_SUMMARY.RESOLUTION
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "DTO.WALLET.PNL_SUMMARY.RESOLUTION",
    ///  "examples": [
    ///    "1d"
    ///  ],
    ///  "type": "string",
    ///  "enum": [
    ///    "1d",
    ///    "7d",
    ///    "30d",
    ///    "all"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum WalletPnlSummaryDtoResolution {
        #[serde(rename = "1d")]
        X1d,
        #[serde(rename = "7d")]
        X7d,
        #[serde(rename = "30d")]
        X30d,
        #[serde(rename = "all")]
        All,
    }
    impl ::std::convert::From<&Self> for WalletPnlSummaryDtoResolution {
        fn from(value: &WalletPnlSummaryDtoResolution) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for WalletPnlSummaryDtoResolution {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::X1d => f.write_str("1d"),
                Self::X7d => f.write_str("7d"),
                Self::X30d => f.write_str("30d"),
                Self::All => f.write_str("all"),
            }
        }
    }
    impl ::std::str::FromStr for WalletPnlSummaryDtoResolution {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "1d" => Ok(Self::X1d),
                "7d" => Ok(Self::X7d),
                "30d" => Ok(Self::X30d),
                "all" => Ok(Self::All),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for WalletPnlSummaryDtoResolution {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<&::std::string::String>
    for WalletPnlSummaryDtoResolution {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    impl ::std::convert::TryFrom<::std::string::String>
    for WalletPnlSummaryDtoResolution {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    ///`WithdrawalAddressIdentificationsResponseDto`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "chainalysisIdentifications",
    ///    "customAddresses"
    ///  ],
    ///  "properties": {
    ///    "chainalysisIdentifications": {
    ///      "description": "DTO.KYT.WITHDRAWAL_ADDRESS_IDENTIFICATIONS_RESPONSE.CHAINALYSIS_IDENTIFICATIONS",
    ///      "type": "array",
    ///      "items": {
    ///        "$ref": "#/components/schemas/ChainalysisAddressIdentification"
    ///      }
    ///    },
    ///    "customAddresses": {
    ///      "description": "DTO.KYT.WITHDRAWAL_ADDRESS_IDENTIFICATIONS_RESPONSE.CUSTOM_ADDRESSES",
    ///      "examples": [
    ///        []
    ///      ],
    ///      "type": "array",
    ///      "items": {
    ///        "type": "string"
    ///      }
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct WithdrawalAddressIdentificationsResponseDto {
        ///DTO.KYT.WITHDRAWAL_ADDRESS_IDENTIFICATIONS_RESPONSE.CHAINALYSIS_IDENTIFICATIONS
        #[serde(rename = "chainalysisIdentifications")]
        pub chainalysis_identifications: ::std::vec::Vec<
            ChainalysisAddressIdentification,
        >,
        ///DTO.KYT.WITHDRAWAL_ADDRESS_IDENTIFICATIONS_RESPONSE.CUSTOM_ADDRESSES
        #[serde(rename = "customAddresses")]
        pub custom_addresses: ::std::vec::Vec<::std::string::String>,
    }
    impl ::std::convert::From<&WithdrawalAddressIdentificationsResponseDto>
    for WithdrawalAddressIdentificationsResponseDto {
        fn from(value: &WithdrawalAddressIdentificationsResponseDto) -> Self {
            value.clone()
        }
    }
    impl WithdrawalAddressIdentificationsResponseDto {
        pub fn builder() -> builder::WithdrawalAddressIdentificationsResponseDto {
            Default::default()
        }
    }
    ///`WithdrawalBaseResponseDto`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "address",
    ///    "asset",
    ///    "assetAmount",
    ///    "assetId",
    ///    "attemptIdentifier",
    ///    "externalId",
    ///    "memo",
    ///    "network",
    ///    "updatedAt",
    ///    "usdAmount"
    ///  ],
    ///  "properties": {
    ///    "address": {
    ///      "description": "DTO.KYT.WITHDRAWAL_BASE_RESPONSE.ADDRESS",
    ///      "examples": [
    ///        "1EM4e8eu2S2RQrbS8C6aYnunWpkAwQ8GtG"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "asset": {
    ///      "description": "DTO.KYT.WITHDRAWAL_BASE_RESPONSE.ASSET",
    ///      "examples": [
    ///        "BTC"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "assetAmount": {
    ///      "description": "DTO.KYT.WITHDRAWAL_BASE_RESPONSE.ASSET_AMOUNT",
    ///      "examples": [
    ///        "5"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "assetId": {
    ///      "description": "DTO.KYT.WITHDRAWAL_BASE_RESPONSE.ASSET_ID",
    ///      "type": [
    ///        "string",
    ///        "null"
    ///      ]
    ///    },
    ///    "attemptIdentifier": {
    ///      "description": "DTO.KYT.WITHDRAWAL_BASE_RESPONSE.ATTEMPT_IDENTIFIER",
    ///      "examples": [
    ///        "attempt1"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "externalId": {
    ///      "description": "DTO.KYT.WITHDRAWAL_BASE_RESPONSE.EXTERNAL_ID",
    ///      "examples": [
    ///        "9855b826-2bad-31f2-8a89-96f164293a83"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "memo": {
    ///      "description": "DTO.KYT.WITHDRAWAL_BASE_RESPONSE.MEMO",
    ///      "type": [
    ///        "string",
    ///        "null"
    ///      ]
    ///    },
    ///    "network": {
    ///      "description": "DTO.KYT.WITHDRAWAL_BASE_RESPONSE.NETWORK",
    ///      "examples": [
    ///        "Bitcoin"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "updatedAt": {
    ///      "description": "DTO.KYT.WITHDRAWAL_BASE_RESPONSE.UPDATED_AT",
    ///      "examples": [
    ///        "2020-12-09T17:25:40.008307"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "usdAmount": {
    ///      "description": "DTO.KYT.WITHDRAWAL_BASE_RESPONSE.USD_AMOUNT",
    ///      "examples": [
    ///        "1000"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct WithdrawalBaseResponseDto {
        ///DTO.KYT.WITHDRAWAL_BASE_RESPONSE.ADDRESS
        pub address: ::std::string::String,
        ///DTO.KYT.WITHDRAWAL_BASE_RESPONSE.ASSET
        pub asset: ::std::string::String,
        ///DTO.KYT.WITHDRAWAL_BASE_RESPONSE.ASSET_AMOUNT
        #[serde(rename = "assetAmount")]
        pub asset_amount: ::std::string::String,
        ///DTO.KYT.WITHDRAWAL_BASE_RESPONSE.ASSET_ID
        #[serde(rename = "assetId")]
        pub asset_id: ::std::option::Option<::std::string::String>,
        ///DTO.KYT.WITHDRAWAL_BASE_RESPONSE.ATTEMPT_IDENTIFIER
        #[serde(rename = "attemptIdentifier")]
        pub attempt_identifier: ::std::string::String,
        ///DTO.KYT.WITHDRAWAL_BASE_RESPONSE.EXTERNAL_ID
        #[serde(rename = "externalId")]
        pub external_id: ::std::string::String,
        ///DTO.KYT.WITHDRAWAL_BASE_RESPONSE.MEMO
        pub memo: ::std::option::Option<::std::string::String>,
        ///DTO.KYT.WITHDRAWAL_BASE_RESPONSE.NETWORK
        pub network: ::std::string::String,
        ///DTO.KYT.WITHDRAWAL_BASE_RESPONSE.UPDATED_AT
        #[serde(rename = "updatedAt")]
        pub updated_at: ::std::string::String,
        ///DTO.KYT.WITHDRAWAL_BASE_RESPONSE.USD_AMOUNT
        #[serde(rename = "usdAmount")]
        pub usd_amount: ::std::string::String,
    }
    impl ::std::convert::From<&WithdrawalBaseResponseDto> for WithdrawalBaseResponseDto {
        fn from(value: &WithdrawalBaseResponseDto) -> Self {
            value.clone()
        }
    }
    impl WithdrawalBaseResponseDto {
        pub fn builder() -> builder::WithdrawalBaseResponseDto {
            Default::default()
        }
    }
    ///`WithdrawalFraudAssessmentResponseDto`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "alteryaIdentifications"
    ///  ],
    ///  "properties": {
    ///    "alteryaIdentifications": {
    ///      "description": "DTO.KYT.WITHDRAWAL_FRAUD_ASSESSMENT_RESPONSE.ALTERYA_IDENTIFICATIONS",
    ///      "type": "array",
    ///      "items": {
    ///        "$ref": "#/components/schemas/AlteryaIdentification"
    ///      }
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct WithdrawalFraudAssessmentResponseDto {
        ///DTO.KYT.WITHDRAWAL_FRAUD_ASSESSMENT_RESPONSE.ALTERYA_IDENTIFICATIONS
        #[serde(rename = "alteryaIdentifications")]
        pub alterya_identifications: ::std::vec::Vec<AlteryaIdentification>,
    }
    impl ::std::convert::From<&WithdrawalFraudAssessmentResponseDto>
    for WithdrawalFraudAssessmentResponseDto {
        fn from(value: &WithdrawalFraudAssessmentResponseDto) -> Self {
            value.clone()
        }
    }
    impl WithdrawalFraudAssessmentResponseDto {
        pub fn builder() -> builder::WithdrawalFraudAssessmentResponseDto {
            Default::default()
        }
    }
    /// Types for composing complex structures.
    pub mod builder {
        #[derive(Clone, Debug)]
        pub struct AddressExposure {
            category: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            direction: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            exposure_type: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            value: ::std::result::Result<::std::string::String, ::std::string::String>,
        }
        impl ::std::default::Default for AddressExposure {
            fn default() -> Self {
                Self {
                    category: Err("no value supplied for category".to_string()),
                    direction: Err("no value supplied for direction".to_string()),
                    exposure_type: Err(
                        "no value supplied for exposure_type".to_string(),
                    ),
                    value: Err("no value supplied for value".to_string()),
                }
            }
        }
        impl AddressExposure {
            pub fn category<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.category = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for category: {}", e)
                    });
                self
            }
            pub fn direction<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.direction = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for direction: {}", e)
                    });
                self
            }
            pub fn exposure_type<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.exposure_type = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for exposure_type: {}", e
                        )
                    });
                self
            }
            pub fn value<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.value = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for value: {}", e)
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<AddressExposure> for super::AddressExposure {
            type Error = super::error::ConversionError;
            fn try_from(
                value: AddressExposure,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    category: value.category?,
                    direction: value.direction?,
                    exposure_type: value.exposure_type?,
                    value: value.value?,
                })
            }
        }
        impl ::std::convert::From<super::AddressExposure> for AddressExposure {
            fn from(value: super::AddressExposure) -> Self {
                Self {
                    category: Ok(value.category),
                    direction: Ok(value.direction),
                    exposure_type: Ok(value.exposure_type),
                    value: Ok(value.value),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct AddressRiskResponseDto {
            address: ::std::result::Result<::std::string::String, ::std::string::String>,
            address_identifications: ::std::result::Result<
                ::std::vec::Vec<::std::string::String>,
                ::std::string::String,
            >,
            address_type: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            cluster: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            exposures: ::std::result::Result<
                ::std::vec::Vec<super::AddressExposure>,
                ::std::string::String,
            >,
            risk: ::std::result::Result<::std::string::String, ::std::string::String>,
            risk_reason: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            status: ::std::result::Result<::std::string::String, ::std::string::String>,
            triggers: ::std::result::Result<
                ::std::vec::Vec<::std::string::String>,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for AddressRiskResponseDto {
            fn default() -> Self {
                Self {
                    address: Err("no value supplied for address".to_string()),
                    address_identifications: Err(
                        "no value supplied for address_identifications".to_string(),
                    ),
                    address_type: Err("no value supplied for address_type".to_string()),
                    cluster: Err("no value supplied for cluster".to_string()),
                    exposures: Err("no value supplied for exposures".to_string()),
                    risk: Err("no value supplied for risk".to_string()),
                    risk_reason: Err("no value supplied for risk_reason".to_string()),
                    status: Err("no value supplied for status".to_string()),
                    triggers: Err("no value supplied for triggers".to_string()),
                }
            }
        }
        impl AddressRiskResponseDto {
            pub fn address<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.address = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for address: {}", e)
                    });
                self
            }
            pub fn address_identifications<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::vec::Vec<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.address_identifications = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for address_identifications: {}",
                            e
                        )
                    });
                self
            }
            pub fn address_type<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.address_type = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for address_type: {}", e
                        )
                    });
                self
            }
            pub fn cluster<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.cluster = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for cluster: {}", e)
                    });
                self
            }
            pub fn exposures<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::vec::Vec<super::AddressExposure>>,
                T::Error: ::std::fmt::Display,
            {
                self.exposures = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for exposures: {}", e)
                    });
                self
            }
            pub fn risk<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.risk = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for risk: {}", e)
                    });
                self
            }
            pub fn risk_reason<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.risk_reason = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for risk_reason: {}", e)
                    });
                self
            }
            pub fn status<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.status = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for status: {}", e)
                    });
                self
            }
            pub fn triggers<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::vec::Vec<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.triggers = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for triggers: {}", e)
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<AddressRiskResponseDto>
        for super::AddressRiskResponseDto {
            type Error = super::error::ConversionError;
            fn try_from(
                value: AddressRiskResponseDto,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    address: value.address?,
                    address_identifications: value.address_identifications?,
                    address_type: value.address_type?,
                    cluster: value.cluster?,
                    exposures: value.exposures?,
                    risk: value.risk?,
                    risk_reason: value.risk_reason?,
                    status: value.status?,
                    triggers: value.triggers?,
                })
            }
        }
        impl ::std::convert::From<super::AddressRiskResponseDto>
        for AddressRiskResponseDto {
            fn from(value: super::AddressRiskResponseDto) -> Self {
                Self {
                    address: Ok(value.address),
                    address_identifications: Ok(value.address_identifications),
                    address_type: Ok(value.address_type),
                    cluster: Ok(value.cluster),
                    exposures: Ok(value.exposures),
                    risk: Ok(value.risk),
                    risk_reason: Ok(value.risk_reason),
                    status: Ok(value.status),
                    triggers: Ok(value.triggers),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct AlertDetail {
            alert_amount: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            alert_level: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            category_id: ::std::result::Result<i64, ::std::string::String>,
            exposure_type: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            external_id: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            memo: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            service: ::std::result::Result<::std::string::String, ::std::string::String>,
        }
        impl ::std::default::Default for AlertDetail {
            fn default() -> Self {
                Self {
                    alert_amount: Err("no value supplied for alert_amount".to_string()),
                    alert_level: Err("no value supplied for alert_level".to_string()),
                    category_id: Err("no value supplied for category_id".to_string()),
                    exposure_type: Err(
                        "no value supplied for exposure_type".to_string(),
                    ),
                    external_id: Err("no value supplied for external_id".to_string()),
                    memo: Err("no value supplied for memo".to_string()),
                    service: Err("no value supplied for service".to_string()),
                }
            }
        }
        impl AlertDetail {
            pub fn alert_amount<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.alert_amount = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for alert_amount: {}", e
                        )
                    });
                self
            }
            pub fn alert_level<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.alert_level = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for alert_level: {}", e)
                    });
                self
            }
            pub fn category_id<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<i64>,
                T::Error: ::std::fmt::Display,
            {
                self.category_id = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for category_id: {}", e)
                    });
                self
            }
            pub fn exposure_type<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.exposure_type = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for exposure_type: {}", e
                        )
                    });
                self
            }
            pub fn external_id<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.external_id = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for external_id: {}", e)
                    });
                self
            }
            pub fn memo<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.memo = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for memo: {}", e)
                    });
                self
            }
            pub fn service<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.service = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for service: {}", e)
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<AlertDetail> for super::AlertDetail {
            type Error = super::error::ConversionError;
            fn try_from(
                value: AlertDetail,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    alert_amount: value.alert_amount?,
                    alert_level: value.alert_level?,
                    category_id: value.category_id?,
                    exposure_type: value.exposure_type?,
                    external_id: value.external_id?,
                    memo: value.memo?,
                    service: value.service?,
                })
            }
        }
        impl ::std::convert::From<super::AlertDetail> for AlertDetail {
            fn from(value: super::AlertDetail) -> Self {
                Self {
                    alert_amount: Ok(value.alert_amount),
                    alert_level: Ok(value.alert_level),
                    category_id: Ok(value.category_id),
                    exposure_type: Ok(value.exposure_type),
                    external_id: Ok(value.external_id),
                    memo: Ok(value.memo),
                    service: Ok(value.service),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct AlteryaIdentification {
            address: ::std::result::Result<::std::string::String, ::std::string::String>,
            chain: ::std::result::Result<::std::string::String, ::std::string::String>,
            labels: ::std::result::Result<
                ::std::vec::Vec<::std::string::String>,
                ::std::string::String,
            >,
            object: ::std::result::Result<::std::string::String, ::std::string::String>,
            on_chain_activity: ::std::result::Result<
                super::OnChainActivity,
                ::std::string::String,
            >,
            reason: ::std::result::Result<::std::string::String, ::std::string::String>,
            risk_level: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            risk_score: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for AlteryaIdentification {
            fn default() -> Self {
                Self {
                    address: Err("no value supplied for address".to_string()),
                    chain: Err("no value supplied for chain".to_string()),
                    labels: Err("no value supplied for labels".to_string()),
                    object: Err("no value supplied for object".to_string()),
                    on_chain_activity: Err(
                        "no value supplied for on_chain_activity".to_string(),
                    ),
                    reason: Err("no value supplied for reason".to_string()),
                    risk_level: Err("no value supplied for risk_level".to_string()),
                    risk_score: Err("no value supplied for risk_score".to_string()),
                }
            }
        }
        impl AlteryaIdentification {
            pub fn address<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.address = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for address: {}", e)
                    });
                self
            }
            pub fn chain<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.chain = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for chain: {}", e)
                    });
                self
            }
            pub fn labels<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::vec::Vec<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.labels = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for labels: {}", e)
                    });
                self
            }
            pub fn object<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.object = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for object: {}", e)
                    });
                self
            }
            pub fn on_chain_activity<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<super::OnChainActivity>,
                T::Error: ::std::fmt::Display,
            {
                self.on_chain_activity = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for on_chain_activity: {}",
                            e
                        )
                    });
                self
            }
            pub fn reason<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.reason = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for reason: {}", e)
                    });
                self
            }
            pub fn risk_level<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.risk_level = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for risk_level: {}", e)
                    });
                self
            }
            pub fn risk_score<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.risk_score = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for risk_score: {}", e)
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<AlteryaIdentification>
        for super::AlteryaIdentification {
            type Error = super::error::ConversionError;
            fn try_from(
                value: AlteryaIdentification,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    address: value.address?,
                    chain: value.chain?,
                    labels: value.labels?,
                    object: value.object?,
                    on_chain_activity: value.on_chain_activity?,
                    reason: value.reason?,
                    risk_level: value.risk_level?,
                    risk_score: value.risk_score?,
                })
            }
        }
        impl ::std::convert::From<super::AlteryaIdentification>
        for AlteryaIdentification {
            fn from(value: super::AlteryaIdentification) -> Self {
                Self {
                    address: Ok(value.address),
                    chain: Ok(value.chain),
                    labels: Ok(value.labels),
                    object: Ok(value.object),
                    on_chain_activity: Ok(value.on_chain_activity),
                    reason: Ok(value.reason),
                    risk_level: Ok(value.risk_level),
                    risk_score: Ok(value.risk_score),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct BalanceUpdateDto {
            account_owner_address: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            balance_change: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            balance_change_in_native: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            balance_change_in_usd: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            block_hash: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            block_height: ::std::result::Result<i64, ::std::string::String>,
            block_slot: ::std::result::Result<i64, ::std::string::String>,
            block_timestamp: ::std::result::Result<i64, ::std::string::String>,
            change_type: ::std::result::Result<
                super::BalanceChangeType,
                ::std::string::String,
            >,
            index: ::std::result::Result<i64, ::std::string::String>,
            post_balance: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            post_balance_in_native: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            post_balance_in_usd: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            pre_balance: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            pre_balance_in_native: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            pre_balance_in_usd: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            token_account_address: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            token_address: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            transaction_signature: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            type_: ::std::result::Result<super::BalanceTokenType, ::std::string::String>,
        }
        impl ::std::default::Default for BalanceUpdateDto {
            fn default() -> Self {
                Self {
                    account_owner_address: Err(
                        "no value supplied for account_owner_address".to_string(),
                    ),
                    balance_change: Err(
                        "no value supplied for balance_change".to_string(),
                    ),
                    balance_change_in_native: Err(
                        "no value supplied for balance_change_in_native".to_string(),
                    ),
                    balance_change_in_usd: Err(
                        "no value supplied for balance_change_in_usd".to_string(),
                    ),
                    block_hash: Err("no value supplied for block_hash".to_string()),
                    block_height: Err("no value supplied for block_height".to_string()),
                    block_slot: Err("no value supplied for block_slot".to_string()),
                    block_timestamp: Err(
                        "no value supplied for block_timestamp".to_string(),
                    ),
                    change_type: Err("no value supplied for change_type".to_string()),
                    index: Err("no value supplied for index".to_string()),
                    post_balance: Err("no value supplied for post_balance".to_string()),
                    post_balance_in_native: Err(
                        "no value supplied for post_balance_in_native".to_string(),
                    ),
                    post_balance_in_usd: Err(
                        "no value supplied for post_balance_in_usd".to_string(),
                    ),
                    pre_balance: Err("no value supplied for pre_balance".to_string()),
                    pre_balance_in_native: Err(
                        "no value supplied for pre_balance_in_native".to_string(),
                    ),
                    pre_balance_in_usd: Err(
                        "no value supplied for pre_balance_in_usd".to_string(),
                    ),
                    token_account_address: Err(
                        "no value supplied for token_account_address".to_string(),
                    ),
                    token_address: Err(
                        "no value supplied for token_address".to_string(),
                    ),
                    transaction_signature: Err(
                        "no value supplied for transaction_signature".to_string(),
                    ),
                    type_: Err("no value supplied for type_".to_string()),
                }
            }
        }
        impl BalanceUpdateDto {
            pub fn account_owner_address<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.account_owner_address = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for account_owner_address: {}",
                            e
                        )
                    });
                self
            }
            pub fn balance_change<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.balance_change = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for balance_change: {}", e
                        )
                    });
                self
            }
            pub fn balance_change_in_native<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.balance_change_in_native = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for balance_change_in_native: {}",
                            e
                        )
                    });
                self
            }
            pub fn balance_change_in_usd<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.balance_change_in_usd = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for balance_change_in_usd: {}",
                            e
                        )
                    });
                self
            }
            pub fn block_hash<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.block_hash = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for block_hash: {}", e)
                    });
                self
            }
            pub fn block_height<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<i64>,
                T::Error: ::std::fmt::Display,
            {
                self.block_height = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for block_height: {}", e
                        )
                    });
                self
            }
            pub fn block_slot<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<i64>,
                T::Error: ::std::fmt::Display,
            {
                self.block_slot = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for block_slot: {}", e)
                    });
                self
            }
            pub fn block_timestamp<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<i64>,
                T::Error: ::std::fmt::Display,
            {
                self.block_timestamp = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for block_timestamp: {}", e
                        )
                    });
                self
            }
            pub fn change_type<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<super::BalanceChangeType>,
                T::Error: ::std::fmt::Display,
            {
                self.change_type = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for change_type: {}", e)
                    });
                self
            }
            pub fn index<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<i64>,
                T::Error: ::std::fmt::Display,
            {
                self.index = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for index: {}", e)
                    });
                self
            }
            pub fn post_balance<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.post_balance = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for post_balance: {}", e
                        )
                    });
                self
            }
            pub fn post_balance_in_native<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.post_balance_in_native = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for post_balance_in_native: {}",
                            e
                        )
                    });
                self
            }
            pub fn post_balance_in_usd<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.post_balance_in_usd = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for post_balance_in_usd: {}",
                            e
                        )
                    });
                self
            }
            pub fn pre_balance<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.pre_balance = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for pre_balance: {}", e)
                    });
                self
            }
            pub fn pre_balance_in_native<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.pre_balance_in_native = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for pre_balance_in_native: {}",
                            e
                        )
                    });
                self
            }
            pub fn pre_balance_in_usd<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.pre_balance_in_usd = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for pre_balance_in_usd: {}",
                            e
                        )
                    });
                self
            }
            pub fn token_account_address<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.token_account_address = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for token_account_address: {}",
                            e
                        )
                    });
                self
            }
            pub fn token_address<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.token_address = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for token_address: {}", e
                        )
                    });
                self
            }
            pub fn transaction_signature<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.transaction_signature = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for transaction_signature: {}",
                            e
                        )
                    });
                self
            }
            pub fn type_<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<super::BalanceTokenType>,
                T::Error: ::std::fmt::Display,
            {
                self.type_ = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for type_: {}", e)
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<BalanceUpdateDto> for super::BalanceUpdateDto {
            type Error = super::error::ConversionError;
            fn try_from(
                value: BalanceUpdateDto,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    account_owner_address: value.account_owner_address?,
                    balance_change: value.balance_change?,
                    balance_change_in_native: value.balance_change_in_native?,
                    balance_change_in_usd: value.balance_change_in_usd?,
                    block_hash: value.block_hash?,
                    block_height: value.block_height?,
                    block_slot: value.block_slot?,
                    block_timestamp: value.block_timestamp?,
                    change_type: value.change_type?,
                    index: value.index?,
                    post_balance: value.post_balance?,
                    post_balance_in_native: value.post_balance_in_native?,
                    post_balance_in_usd: value.post_balance_in_usd?,
                    pre_balance: value.pre_balance?,
                    pre_balance_in_native: value.pre_balance_in_native?,
                    pre_balance_in_usd: value.pre_balance_in_usd?,
                    token_account_address: value.token_account_address?,
                    token_address: value.token_address?,
                    transaction_signature: value.transaction_signature?,
                    type_: value.type_?,
                })
            }
        }
        impl ::std::convert::From<super::BalanceUpdateDto> for BalanceUpdateDto {
            fn from(value: super::BalanceUpdateDto) -> Self {
                Self {
                    account_owner_address: Ok(value.account_owner_address),
                    balance_change: Ok(value.balance_change),
                    balance_change_in_native: Ok(value.balance_change_in_native),
                    balance_change_in_usd: Ok(value.balance_change_in_usd),
                    block_hash: Ok(value.block_hash),
                    block_height: Ok(value.block_height),
                    block_slot: Ok(value.block_slot),
                    block_timestamp: Ok(value.block_timestamp),
                    change_type: Ok(value.change_type),
                    index: Ok(value.index),
                    post_balance: Ok(value.post_balance),
                    post_balance_in_native: Ok(value.post_balance_in_native),
                    post_balance_in_usd: Ok(value.post_balance_in_usd),
                    pre_balance: Ok(value.pre_balance),
                    pre_balance_in_native: Ok(value.pre_balance_in_native),
                    pre_balance_in_usd: Ok(value.pre_balance_in_usd),
                    token_account_address: Ok(value.token_account_address),
                    token_address: Ok(value.token_address),
                    transaction_signature: Ok(value.transaction_signature),
                    type_: Ok(value.type_),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct BalanceUpdatePage {
            data: ::std::result::Result<
                ::std::vec::Vec<super::BalanceUpdateDto>,
                ::std::string::String,
            >,
            end_cursor: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            has_next: ::std::result::Result<bool, ::std::string::String>,
            has_prev: ::std::result::Result<bool, ::std::string::String>,
            start_cursor: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for BalanceUpdatePage {
            fn default() -> Self {
                Self {
                    data: Err("no value supplied for data".to_string()),
                    end_cursor: Ok(Default::default()),
                    has_next: Err("no value supplied for has_next".to_string()),
                    has_prev: Err("no value supplied for has_prev".to_string()),
                    start_cursor: Ok(Default::default()),
                }
            }
        }
        impl BalanceUpdatePage {
            pub fn data<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::vec::Vec<super::BalanceUpdateDto>>,
                T::Error: ::std::fmt::Display,
            {
                self.data = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for data: {}", e)
                    });
                self
            }
            pub fn end_cursor<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.end_cursor = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for end_cursor: {}", e)
                    });
                self
            }
            pub fn has_next<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<bool>,
                T::Error: ::std::fmt::Display,
            {
                self.has_next = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for has_next: {}", e)
                    });
                self
            }
            pub fn has_prev<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<bool>,
                T::Error: ::std::fmt::Display,
            {
                self.has_prev = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for has_prev: {}", e)
                    });
                self
            }
            pub fn start_cursor<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.start_cursor = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for start_cursor: {}", e
                        )
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<BalanceUpdatePage> for super::BalanceUpdatePage {
            type Error = super::error::ConversionError;
            fn try_from(
                value: BalanceUpdatePage,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    data: value.data?,
                    end_cursor: value.end_cursor?,
                    has_next: value.has_next?,
                    has_prev: value.has_prev?,
                    start_cursor: value.start_cursor?,
                })
            }
        }
        impl ::std::convert::From<super::BalanceUpdatePage> for BalanceUpdatePage {
            fn from(value: super::BalanceUpdatePage) -> Self {
                Self {
                    data: Ok(value.data),
                    end_cursor: Ok(value.end_cursor),
                    has_next: Ok(value.has_next),
                    has_prev: Ok(value.has_prev),
                    start_cursor: Ok(value.start_cursor),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct BlockchainDto {
            chain_id: ::std::result::Result<i64, ::std::string::String>,
            explorer_url: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            name: ::std::result::Result<::std::string::String, ::std::string::String>,
            symbol: ::std::result::Result<::std::string::String, ::std::string::String>,
        }
        impl ::std::default::Default for BlockchainDto {
            fn default() -> Self {
                Self {
                    chain_id: Err("no value supplied for chain_id".to_string()),
                    explorer_url: Err("no value supplied for explorer_url".to_string()),
                    name: Err("no value supplied for name".to_string()),
                    symbol: Err("no value supplied for symbol".to_string()),
                }
            }
        }
        impl BlockchainDto {
            pub fn chain_id<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<i64>,
                T::Error: ::std::fmt::Display,
            {
                self.chain_id = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for chain_id: {}", e)
                    });
                self
            }
            pub fn explorer_url<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.explorer_url = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for explorer_url: {}", e
                        )
                    });
                self
            }
            pub fn name<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.name = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for name: {}", e)
                    });
                self
            }
            pub fn symbol<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.symbol = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for symbol: {}", e)
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<BlockchainDto> for super::BlockchainDto {
            type Error = super::error::ConversionError;
            fn try_from(
                value: BlockchainDto,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    chain_id: value.chain_id?,
                    explorer_url: value.explorer_url?,
                    name: value.name?,
                    symbol: value.symbol?,
                })
            }
        }
        impl ::std::convert::From<super::BlockchainDto> for BlockchainDto {
            fn from(value: super::BlockchainDto) -> Self {
                Self {
                    chain_id: Ok(value.chain_id),
                    explorer_url: Ok(value.explorer_url),
                    name: Ok(value.name),
                    symbol: Ok(value.symbol),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct BlockchainLatestBlockDto {
            blockhash: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            last_valid_block_height: ::std::result::Result<i64, ::std::string::String>,
        }
        impl ::std::default::Default for BlockchainLatestBlockDto {
            fn default() -> Self {
                Self {
                    blockhash: Err("no value supplied for blockhash".to_string()),
                    last_valid_block_height: Err(
                        "no value supplied for last_valid_block_height".to_string(),
                    ),
                }
            }
        }
        impl BlockchainLatestBlockDto {
            pub fn blockhash<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.blockhash = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for blockhash: {}", e)
                    });
                self
            }
            pub fn last_valid_block_height<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<i64>,
                T::Error: ::std::fmt::Display,
            {
                self.last_valid_block_height = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for last_valid_block_height: {}",
                            e
                        )
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<BlockchainLatestBlockDto>
        for super::BlockchainLatestBlockDto {
            type Error = super::error::ConversionError;
            fn try_from(
                value: BlockchainLatestBlockDto,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    blockhash: value.blockhash?,
                    last_valid_block_height: value.last_valid_block_height?,
                })
            }
        }
        impl ::std::convert::From<super::BlockchainLatestBlockDto>
        for BlockchainLatestBlockDto {
            fn from(value: super::BlockchainLatestBlockDto) -> Self {
                Self {
                    blockhash: Ok(value.blockhash),
                    last_valid_block_height: Ok(value.last_valid_block_height),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct BooleanResultDto {
            success: ::std::result::Result<bool, ::std::string::String>,
        }
        impl ::std::default::Default for BooleanResultDto {
            fn default() -> Self {
                Self {
                    success: Err("no value supplied for success".to_string()),
                }
            }
        }
        impl BooleanResultDto {
            pub fn success<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<bool>,
                T::Error: ::std::fmt::Display,
            {
                self.success = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for success: {}", e)
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<BooleanResultDto> for super::BooleanResultDto {
            type Error = super::error::ConversionError;
            fn try_from(
                value: BooleanResultDto,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self { success: value.success? })
            }
        }
        impl ::std::convert::From<super::BooleanResultDto> for BooleanResultDto {
            fn from(value: super::BooleanResultDto) -> Self {
                Self { success: Ok(value.success) }
            }
        }
        #[derive(Clone, Debug)]
        pub struct CalculatePnlInput {
            token_addresses: ::std::result::Result<
                ::std::vec::Vec<::std::string::String>,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for CalculatePnlInput {
            fn default() -> Self {
                Self {
                    token_addresses: Ok(Default::default()),
                }
            }
        }
        impl CalculatePnlInput {
            pub fn token_addresses<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::vec::Vec<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.token_addresses = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for token_addresses: {}", e
                        )
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<CalculatePnlInput> for super::CalculatePnlInput {
            type Error = super::error::ConversionError;
            fn try_from(
                value: CalculatePnlInput,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    token_addresses: value.token_addresses?,
                })
            }
        }
        impl ::std::convert::From<super::CalculatePnlInput> for CalculatePnlInput {
            fn from(value: super::CalculatePnlInput) -> Self {
                Self {
                    token_addresses: Ok(value.token_addresses),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct Candle {
            close: ::std::result::Result<::std::string::String, ::std::string::String>,
            high: ::std::result::Result<::std::string::String, ::std::string::String>,
            low: ::std::result::Result<::std::string::String, ::std::string::String>,
            open: ::std::result::Result<::std::string::String, ::std::string::String>,
            resolution: ::std::result::Result<super::Resolution, ::std::string::String>,
            time: ::std::result::Result<i64, ::std::string::String>,
            trades: ::std::result::Result<i64, ::std::string::String>,
            updated_at: ::std::result::Result<i64, ::std::string::String>,
            volume: ::std::result::Result<::std::string::String, ::std::string::String>,
        }
        impl ::std::default::Default for Candle {
            fn default() -> Self {
                Self {
                    close: Err("no value supplied for close".to_string()),
                    high: Err("no value supplied for high".to_string()),
                    low: Err("no value supplied for low".to_string()),
                    open: Err("no value supplied for open".to_string()),
                    resolution: Err("no value supplied for resolution".to_string()),
                    time: Err("no value supplied for time".to_string()),
                    trades: Err("no value supplied for trades".to_string()),
                    updated_at: Err("no value supplied for updated_at".to_string()),
                    volume: Err("no value supplied for volume".to_string()),
                }
            }
        }
        impl Candle {
            pub fn close<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.close = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for close: {}", e)
                    });
                self
            }
            pub fn high<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.high = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for high: {}", e)
                    });
                self
            }
            pub fn low<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.low = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for low: {}", e)
                    });
                self
            }
            pub fn open<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.open = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for open: {}", e)
                    });
                self
            }
            pub fn resolution<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<super::Resolution>,
                T::Error: ::std::fmt::Display,
            {
                self.resolution = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for resolution: {}", e)
                    });
                self
            }
            pub fn time<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<i64>,
                T::Error: ::std::fmt::Display,
            {
                self.time = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for time: {}", e)
                    });
                self
            }
            pub fn trades<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<i64>,
                T::Error: ::std::fmt::Display,
            {
                self.trades = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for trades: {}", e)
                    });
                self
            }
            pub fn updated_at<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<i64>,
                T::Error: ::std::fmt::Display,
            {
                self.updated_at = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for updated_at: {}", e)
                    });
                self
            }
            pub fn volume<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.volume = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for volume: {}", e)
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<Candle> for super::Candle {
            type Error = super::error::ConversionError;
            fn try_from(
                value: Candle,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    close: value.close?,
                    high: value.high?,
                    low: value.low?,
                    open: value.open?,
                    resolution: value.resolution?,
                    time: value.time?,
                    trades: value.trades?,
                    updated_at: value.updated_at?,
                    volume: value.volume?,
                })
            }
        }
        impl ::std::convert::From<super::Candle> for Candle {
            fn from(value: super::Candle) -> Self {
                Self {
                    close: Ok(value.close),
                    high: Ok(value.high),
                    low: Ok(value.low),
                    open: Ok(value.open),
                    resolution: Ok(value.resolution),
                    time: Ok(value.time),
                    trades: Ok(value.trades),
                    updated_at: Ok(value.updated_at),
                    volume: Ok(value.volume),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct ChainalysisAddressIdentification {
            address_name: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            category_id: ::std::result::Result<i64, ::std::string::String>,
            description: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for ChainalysisAddressIdentification {
            fn default() -> Self {
                Self {
                    address_name: Err("no value supplied for address_name".to_string()),
                    category_id: Err("no value supplied for category_id".to_string()),
                    description: Err("no value supplied for description".to_string()),
                }
            }
        }
        impl ChainalysisAddressIdentification {
            pub fn address_name<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.address_name = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for address_name: {}", e
                        )
                    });
                self
            }
            pub fn category_id<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<i64>,
                T::Error: ::std::fmt::Display,
            {
                self.category_id = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for category_id: {}", e)
                    });
                self
            }
            pub fn description<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.description = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for description: {}", e)
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<ChainalysisAddressIdentification>
        for super::ChainalysisAddressIdentification {
            type Error = super::error::ConversionError;
            fn try_from(
                value: ChainalysisAddressIdentification,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    address_name: value.address_name?,
                    category_id: value.category_id?,
                    description: value.description?,
                })
            }
        }
        impl ::std::convert::From<super::ChainalysisAddressIdentification>
        for ChainalysisAddressIdentification {
            fn from(value: super::ChainalysisAddressIdentification) -> Self {
                Self {
                    address_name: Ok(value.address_name),
                    category_id: Ok(value.category_id),
                    description: Ok(value.description),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct ClaimRedPacketInput {
            chain: ::std::result::Result<
                super::ClaimRedPacketInputChain,
                ::std::string::String,
            >,
            claimer: ::std::result::Result<::std::string::String, ::std::string::String>,
            packet_id: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            password: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            share_id: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for ClaimRedPacketInput {
            fn default() -> Self {
                Self {
                    chain: Err("no value supplied for chain".to_string()),
                    claimer: Err("no value supplied for claimer".to_string()),
                    packet_id: Ok(Default::default()),
                    password: Ok(Default::default()),
                    share_id: Ok(Default::default()),
                }
            }
        }
        impl ClaimRedPacketInput {
            pub fn chain<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<super::ClaimRedPacketInputChain>,
                T::Error: ::std::fmt::Display,
            {
                self.chain = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for chain: {}", e)
                    });
                self
            }
            pub fn claimer<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.claimer = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for claimer: {}", e)
                    });
                self
            }
            pub fn packet_id<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.packet_id = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for packet_id: {}", e)
                    });
                self
            }
            pub fn password<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.password = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for password: {}", e)
                    });
                self
            }
            pub fn share_id<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.share_id = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for share_id: {}", e)
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<ClaimRedPacketInput>
        for super::ClaimRedPacketInput {
            type Error = super::error::ConversionError;
            fn try_from(
                value: ClaimRedPacketInput,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    chain: value.chain?,
                    claimer: value.claimer?,
                    packet_id: value.packet_id?,
                    password: value.password?,
                    share_id: value.share_id?,
                })
            }
        }
        impl ::std::convert::From<super::ClaimRedPacketInput> for ClaimRedPacketInput {
            fn from(value: super::ClaimRedPacketInput) -> Self {
                Self {
                    chain: Ok(value.chain),
                    claimer: Ok(value.claimer),
                    packet_id: Ok(value.packet_id),
                    password: Ok(value.password),
                    share_id: Ok(value.share_id),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct CreateEndpointInput {
            channels: ::std::result::Result<
                ::std::vec::Vec<super::CreateEndpointInputChannelsItem>,
                ::std::string::String,
            >,
            description: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            disabled: ::std::result::Result<bool, ::std::string::String>,
            filter: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            filter_types: ::std::result::Result<
                ::std::vec::Vec<::std::string::String>,
                ::std::string::String,
            >,
            metadata: ::std::result::Result<
                ::serde_json::Map<::std::string::String, ::serde_json::Value>,
                ::std::string::String,
            >,
            rate_limit: ::std::result::Result<
                ::std::option::Option<i64>,
                ::std::string::String,
            >,
            url: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for CreateEndpointInput {
            fn default() -> Self {
                Self {
                    channels: Ok(Default::default()),
                    description: Ok(Default::default()),
                    disabled: Ok(Default::default()),
                    filter: Ok(Default::default()),
                    filter_types: Ok(Default::default()),
                    metadata: Ok(Default::default()),
                    rate_limit: Ok(Default::default()),
                    url: Ok(Default::default()),
                }
            }
        }
        impl CreateEndpointInput {
            pub fn channels<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<
                    ::std::vec::Vec<super::CreateEndpointInputChannelsItem>,
                >,
                T::Error: ::std::fmt::Display,
            {
                self.channels = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for channels: {}", e)
                    });
                self
            }
            pub fn description<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.description = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for description: {}", e)
                    });
                self
            }
            pub fn disabled<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<bool>,
                T::Error: ::std::fmt::Display,
            {
                self.disabled = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for disabled: {}", e)
                    });
                self
            }
            pub fn filter<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.filter = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for filter: {}", e)
                    });
                self
            }
            pub fn filter_types<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::vec::Vec<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.filter_types = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for filter_types: {}", e
                        )
                    });
                self
            }
            pub fn metadata<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<
                    ::serde_json::Map<::std::string::String, ::serde_json::Value>,
                >,
                T::Error: ::std::fmt::Display,
            {
                self.metadata = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for metadata: {}", e)
                    });
                self
            }
            pub fn rate_limit<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<i64>>,
                T::Error: ::std::fmt::Display,
            {
                self.rate_limit = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for rate_limit: {}", e)
                    });
                self
            }
            pub fn url<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.url = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for url: {}", e)
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<CreateEndpointInput>
        for super::CreateEndpointInput {
            type Error = super::error::ConversionError;
            fn try_from(
                value: CreateEndpointInput,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    channels: value.channels?,
                    description: value.description?,
                    disabled: value.disabled?,
                    filter: value.filter?,
                    filter_types: value.filter_types?,
                    metadata: value.metadata?,
                    rate_limit: value.rate_limit?,
                    url: value.url?,
                })
            }
        }
        impl ::std::convert::From<super::CreateEndpointInput> for CreateEndpointInput {
            fn from(value: super::CreateEndpointInput) -> Self {
                Self {
                    channels: Ok(value.channels),
                    description: Ok(value.description),
                    disabled: Ok(value.disabled),
                    filter: Ok(value.filter),
                    filter_types: Ok(value.filter_types),
                    metadata: Ok(value.metadata),
                    rate_limit: Ok(value.rate_limit),
                    url: Ok(value.url),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct CreateRedPacketInput {
            chain: ::std::result::Result<
                super::CreateRedPacketInputChain,
                ::std::string::String,
            >,
            claim_authority: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            creator: ::std::result::Result<
                super::CreateRedPacketInputCreator,
                ::std::string::String,
            >,
            fixed_amount: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            max_claims: ::std::result::Result<
                ::std::num::NonZeroU64,
                ::std::string::String,
            >,
            memo: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            mint: ::std::result::Result<::std::string::String, ::std::string::String>,
            password: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            total_amount: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for CreateRedPacketInput {
            fn default() -> Self {
                Self {
                    chain: Err("no value supplied for chain".to_string()),
                    claim_authority: Ok(Default::default()),
                    creator: Err("no value supplied for creator".to_string()),
                    fixed_amount: Ok(Default::default()),
                    max_claims: Err("no value supplied for max_claims".to_string()),
                    memo: Ok(Default::default()),
                    mint: Err("no value supplied for mint".to_string()),
                    password: Ok(Default::default()),
                    total_amount: Ok(Default::default()),
                }
            }
        }
        impl CreateRedPacketInput {
            pub fn chain<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<super::CreateRedPacketInputChain>,
                T::Error: ::std::fmt::Display,
            {
                self.chain = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for chain: {}", e)
                    });
                self
            }
            pub fn claim_authority<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.claim_authority = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for claim_authority: {}", e
                        )
                    });
                self
            }
            pub fn creator<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<super::CreateRedPacketInputCreator>,
                T::Error: ::std::fmt::Display,
            {
                self.creator = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for creator: {}", e)
                    });
                self
            }
            pub fn fixed_amount<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.fixed_amount = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for fixed_amount: {}", e
                        )
                    });
                self
            }
            pub fn max_claims<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::num::NonZeroU64>,
                T::Error: ::std::fmt::Display,
            {
                self.max_claims = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for max_claims: {}", e)
                    });
                self
            }
            pub fn memo<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.memo = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for memo: {}", e)
                    });
                self
            }
            pub fn mint<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.mint = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for mint: {}", e)
                    });
                self
            }
            pub fn password<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.password = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for password: {}", e)
                    });
                self
            }
            pub fn total_amount<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.total_amount = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for total_amount: {}", e
                        )
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<CreateRedPacketInput>
        for super::CreateRedPacketInput {
            type Error = super::error::ConversionError;
            fn try_from(
                value: CreateRedPacketInput,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    chain: value.chain?,
                    claim_authority: value.claim_authority?,
                    creator: value.creator?,
                    fixed_amount: value.fixed_amount?,
                    max_claims: value.max_claims?,
                    memo: value.memo?,
                    mint: value.mint?,
                    password: value.password?,
                    total_amount: value.total_amount?,
                })
            }
        }
        impl ::std::convert::From<super::CreateRedPacketInput> for CreateRedPacketInput {
            fn from(value: super::CreateRedPacketInput) -> Self {
                Self {
                    chain: Ok(value.chain),
                    claim_authority: Ok(value.claim_authority),
                    creator: Ok(value.creator),
                    fixed_amount: Ok(value.fixed_amount),
                    max_claims: Ok(value.max_claims),
                    memo: Ok(value.memo),
                    mint: Ok(value.mint),
                    password: Ok(value.password),
                    total_amount: Ok(value.total_amount),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct CreateRedPacketReply {
            share_id: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            tx_serialize: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for CreateRedPacketReply {
            fn default() -> Self {
                Self {
                    share_id: Err("no value supplied for share_id".to_string()),
                    tx_serialize: Err("no value supplied for tx_serialize".to_string()),
                }
            }
        }
        impl CreateRedPacketReply {
            pub fn share_id<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.share_id = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for share_id: {}", e)
                    });
                self
            }
            pub fn tx_serialize<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.tx_serialize = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for tx_serialize: {}", e
                        )
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<CreateRedPacketReply>
        for super::CreateRedPacketReply {
            type Error = super::error::ConversionError;
            fn try_from(
                value: CreateRedPacketReply,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    share_id: value.share_id?,
                    tx_serialize: value.tx_serialize?,
                })
            }
        }
        impl ::std::convert::From<super::CreateRedPacketReply> for CreateRedPacketReply {
            fn from(value: super::CreateRedPacketReply) -> Self {
                Self {
                    share_id: Ok(value.share_id),
                    tx_serialize: Ok(value.tx_serialize),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct CreateTokenInput {
            dex: ::std::result::Result<
                super::CreateTokenInputDex,
                ::std::string::String,
            >,
            extra: ::std::result::Result<
                ::serde_json::Map<::std::string::String, ::serde_json::Value>,
                ::std::string::String,
            >,
            image: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            name: ::std::result::Result<
                super::CreateTokenInputName,
                ::std::string::String,
            >,
            priority_fee: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            symbol: ::std::result::Result<
                super::CreateTokenInputSymbol,
                ::std::string::String,
            >,
            uri: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            user_address: ::std::result::Result<
                super::CreateTokenInputUserAddress,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for CreateTokenInput {
            fn default() -> Self {
                Self {
                    dex: Err("no value supplied for dex".to_string()),
                    extra: Ok(Default::default()),
                    image: Ok(Default::default()),
                    name: Err("no value supplied for name".to_string()),
                    priority_fee: Ok(Default::default()),
                    symbol: Err("no value supplied for symbol".to_string()),
                    uri: Ok(Default::default()),
                    user_address: Err("no value supplied for user_address".to_string()),
                }
            }
        }
        impl CreateTokenInput {
            pub fn dex<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<super::CreateTokenInputDex>,
                T::Error: ::std::fmt::Display,
            {
                self.dex = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for dex: {}", e)
                    });
                self
            }
            pub fn extra<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<
                    ::serde_json::Map<::std::string::String, ::serde_json::Value>,
                >,
                T::Error: ::std::fmt::Display,
            {
                self.extra = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for extra: {}", e)
                    });
                self
            }
            pub fn image<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.image = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for image: {}", e)
                    });
                self
            }
            pub fn name<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<super::CreateTokenInputName>,
                T::Error: ::std::fmt::Display,
            {
                self.name = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for name: {}", e)
                    });
                self
            }
            pub fn priority_fee<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.priority_fee = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for priority_fee: {}", e
                        )
                    });
                self
            }
            pub fn symbol<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<super::CreateTokenInputSymbol>,
                T::Error: ::std::fmt::Display,
            {
                self.symbol = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for symbol: {}", e)
                    });
                self
            }
            pub fn uri<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.uri = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for uri: {}", e)
                    });
                self
            }
            pub fn user_address<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<super::CreateTokenInputUserAddress>,
                T::Error: ::std::fmt::Display,
            {
                self.user_address = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for user_address: {}", e
                        )
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<CreateTokenInput> for super::CreateTokenInput {
            type Error = super::error::ConversionError;
            fn try_from(
                value: CreateTokenInput,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    dex: value.dex?,
                    extra: value.extra?,
                    image: value.image?,
                    name: value.name?,
                    priority_fee: value.priority_fee?,
                    symbol: value.symbol?,
                    uri: value.uri?,
                    user_address: value.user_address?,
                })
            }
        }
        impl ::std::convert::From<super::CreateTokenInput> for CreateTokenInput {
            fn from(value: super::CreateTokenInput) -> Self {
                Self {
                    dex: Ok(value.dex),
                    extra: Ok(value.extra),
                    image: Ok(value.image),
                    name: Ok(value.name),
                    priority_fee: Ok(value.priority_fee),
                    symbol: Ok(value.symbol),
                    uri: Ok(value.uri),
                    user_address: Ok(value.user_address),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct CreateTokenReply {
            mint_address: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            serialized_tx: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for CreateTokenReply {
            fn default() -> Self {
                Self {
                    mint_address: Err("no value supplied for mint_address".to_string()),
                    serialized_tx: Err("no value supplied for serialized_tx".to_string()),
                }
            }
        }
        impl CreateTokenReply {
            pub fn mint_address<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.mint_address = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for mint_address: {}", e
                        )
                    });
                self
            }
            pub fn serialized_tx<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.serialized_tx = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for serialized_tx: {}", e
                        )
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<CreateTokenReply> for super::CreateTokenReply {
            type Error = super::error::ConversionError;
            fn try_from(
                value: CreateTokenReply,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    mint_address: value.mint_address?,
                    serialized_tx: value.serialized_tx?,
                })
            }
        }
        impl ::std::convert::From<super::CreateTokenReply> for CreateTokenReply {
            fn from(value: super::CreateTokenReply) -> Self {
                Self {
                    mint_address: Ok(value.mint_address),
                    serialized_tx: Ok(value.serialized_tx),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct DevTokenDto {
            address: ::std::result::Result<::std::string::String, ::std::string::String>,
            market_data: ::std::result::Result<
                super::TokenMarketData,
                ::std::string::String,
            >,
            metadata: ::std::result::Result<super::TokenMetadata, ::std::string::String>,
            stats: ::std::result::Result<super::TokenStat, ::std::string::String>,
        }
        impl ::std::default::Default for DevTokenDto {
            fn default() -> Self {
                Self {
                    address: Err("no value supplied for address".to_string()),
                    market_data: Err("no value supplied for market_data".to_string()),
                    metadata: Err("no value supplied for metadata".to_string()),
                    stats: Err("no value supplied for stats".to_string()),
                }
            }
        }
        impl DevTokenDto {
            pub fn address<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.address = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for address: {}", e)
                    });
                self
            }
            pub fn market_data<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<super::TokenMarketData>,
                T::Error: ::std::fmt::Display,
            {
                self.market_data = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for market_data: {}", e)
                    });
                self
            }
            pub fn metadata<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<super::TokenMetadata>,
                T::Error: ::std::fmt::Display,
            {
                self.metadata = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for metadata: {}", e)
                    });
                self
            }
            pub fn stats<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<super::TokenStat>,
                T::Error: ::std::fmt::Display,
            {
                self.stats = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for stats: {}", e)
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<DevTokenDto> for super::DevTokenDto {
            type Error = super::error::ConversionError;
            fn try_from(
                value: DevTokenDto,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    address: value.address?,
                    market_data: value.market_data?,
                    metadata: value.metadata?,
                    stats: value.stats?,
                })
            }
        }
        impl ::std::convert::From<super::DevTokenDto> for DevTokenDto {
            fn from(value: super::DevTokenDto) -> Self {
                Self {
                    address: Ok(value.address),
                    market_data: Ok(value.market_data),
                    metadata: Ok(value.metadata),
                    stats: Ok(value.stats),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct DexDto {
            chain: ::std::result::Result<::std::string::String, ::std::string::String>,
            image: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            program_address: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            protocol_family: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for DexDto {
            fn default() -> Self {
                Self {
                    chain: Err("no value supplied for chain".to_string()),
                    image: Ok(Default::default()),
                    program_address: Ok(Default::default()),
                    protocol_family: Ok(Default::default()),
                }
            }
        }
        impl DexDto {
            pub fn chain<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.chain = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for chain: {}", e)
                    });
                self
            }
            pub fn image<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.image = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for image: {}", e)
                    });
                self
            }
            pub fn program_address<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.program_address = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for program_address: {}", e
                        )
                    });
                self
            }
            pub fn protocol_family<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.protocol_family = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for protocol_family: {}", e
                        )
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<DexDto> for super::DexDto {
            type Error = super::error::ConversionError;
            fn try_from(
                value: DexDto,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    chain: value.chain?,
                    image: value.image?,
                    program_address: value.program_address?,
                    protocol_family: value.protocol_family?,
                })
            }
        }
        impl ::std::convert::From<super::DexDto> for DexDto {
            fn from(value: super::DexDto) -> Self {
                Self {
                    chain: Ok(value.chain),
                    image: Ok(value.image),
                    program_address: Ok(value.program_address),
                    protocol_family: Ok(value.protocol_family),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct DexPage {
            data: ::std::result::Result<
                ::std::vec::Vec<super::DexDto>,
                ::std::string::String,
            >,
            end_cursor: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            has_next: ::std::result::Result<bool, ::std::string::String>,
            has_prev: ::std::result::Result<bool, ::std::string::String>,
            start_cursor: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            total: ::std::result::Result<i64, ::std::string::String>,
        }
        impl ::std::default::Default for DexPage {
            fn default() -> Self {
                Self {
                    data: Err("no value supplied for data".to_string()),
                    end_cursor: Ok(Default::default()),
                    has_next: Ok(Default::default()),
                    has_prev: Ok(Default::default()),
                    start_cursor: Ok(Default::default()),
                    total: Ok(Default::default()),
                }
            }
        }
        impl DexPage {
            pub fn data<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::vec::Vec<super::DexDto>>,
                T::Error: ::std::fmt::Display,
            {
                self.data = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for data: {}", e)
                    });
                self
            }
            pub fn end_cursor<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.end_cursor = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for end_cursor: {}", e)
                    });
                self
            }
            pub fn has_next<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<bool>,
                T::Error: ::std::fmt::Display,
            {
                self.has_next = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for has_next: {}", e)
                    });
                self
            }
            pub fn has_prev<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<bool>,
                T::Error: ::std::fmt::Display,
            {
                self.has_prev = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for has_prev: {}", e)
                    });
                self
            }
            pub fn start_cursor<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.start_cursor = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for start_cursor: {}", e
                        )
                    });
                self
            }
            pub fn total<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<i64>,
                T::Error: ::std::fmt::Display,
            {
                self.total = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for total: {}", e)
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<DexPage> for super::DexPage {
            type Error = super::error::ConversionError;
            fn try_from(
                value: DexPage,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    data: value.data?,
                    end_cursor: value.end_cursor?,
                    has_next: value.has_next?,
                    has_prev: value.has_prev?,
                    start_cursor: value.start_cursor?,
                    total: value.total?,
                })
            }
        }
        impl ::std::convert::From<super::DexPage> for DexPage {
            fn from(value: super::DexPage) -> Self {
                Self {
                    data: Ok(value.data),
                    end_cursor: Ok(value.end_cursor),
                    has_next: Ok(value.has_next),
                    has_prev: Ok(value.has_prev),
                    start_cursor: Ok(value.start_cursor),
                    total: Ok(value.total),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct DexPoolDto {
            chain: ::std::result::Result<::std::string::String, ::std::string::String>,
            created_block_timestamp: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            fee_rate: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            image: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            liquidity_model: ::std::result::Result<
                ::std::option::Option<super::DexPoolDtoLiquidityModel>,
                ::std::string::String,
            >,
            pool_address: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            program_address: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            protocol_family: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            protocol_name: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            tick_spacing: ::std::result::Result<
                ::std::option::Option<i64>,
                ::std::string::String,
            >,
            token_a_address: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            token_a_liquidity: ::std::result::Result<
                ::std::option::Option<super::DexPoolTokenLiquidity>,
                ::std::string::String,
            >,
            token_b_address: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            token_b_liquidity: ::std::result::Result<
                ::std::option::Option<super::DexPoolTokenLiquidity>,
                ::std::string::String,
            >,
            token_count: ::std::result::Result<
                ::std::option::Option<i64>,
                ::std::string::String,
            >,
            tvl_in_sol: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            tvl_in_usd: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            type_: ::std::result::Result<
                ::std::option::Option<super::DexPoolDtoType>,
                ::std::string::String,
            >,
            version: ::std::result::Result<
                ::std::option::Option<super::DexPoolDtoVersion>,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for DexPoolDto {
            fn default() -> Self {
                Self {
                    chain: Err("no value supplied for chain".to_string()),
                    created_block_timestamp: Ok(Default::default()),
                    fee_rate: Ok(Default::default()),
                    image: Ok(Default::default()),
                    liquidity_model: Ok(Default::default()),
                    pool_address: Err("no value supplied for pool_address".to_string()),
                    program_address: Ok(Default::default()),
                    protocol_family: Ok(Default::default()),
                    protocol_name: Ok(Default::default()),
                    tick_spacing: Ok(Default::default()),
                    token_a_address: Err(
                        "no value supplied for token_a_address".to_string(),
                    ),
                    token_a_liquidity: Ok(Default::default()),
                    token_b_address: Err(
                        "no value supplied for token_b_address".to_string(),
                    ),
                    token_b_liquidity: Ok(Default::default()),
                    token_count: Ok(Default::default()),
                    tvl_in_sol: Ok(Default::default()),
                    tvl_in_usd: Ok(Default::default()),
                    type_: Ok(Default::default()),
                    version: Ok(Default::default()),
                }
            }
        }
        impl DexPoolDto {
            pub fn chain<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.chain = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for chain: {}", e)
                    });
                self
            }
            pub fn created_block_timestamp<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.created_block_timestamp = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for created_block_timestamp: {}",
                            e
                        )
                    });
                self
            }
            pub fn fee_rate<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.fee_rate = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for fee_rate: {}", e)
                    });
                self
            }
            pub fn image<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.image = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for image: {}", e)
                    });
                self
            }
            pub fn liquidity_model<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<
                    ::std::option::Option<super::DexPoolDtoLiquidityModel>,
                >,
                T::Error: ::std::fmt::Display,
            {
                self.liquidity_model = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for liquidity_model: {}", e
                        )
                    });
                self
            }
            pub fn pool_address<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.pool_address = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for pool_address: {}", e
                        )
                    });
                self
            }
            pub fn program_address<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.program_address = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for program_address: {}", e
                        )
                    });
                self
            }
            pub fn protocol_family<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.protocol_family = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for protocol_family: {}", e
                        )
                    });
                self
            }
            pub fn protocol_name<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.protocol_name = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for protocol_name: {}", e
                        )
                    });
                self
            }
            pub fn tick_spacing<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<i64>>,
                T::Error: ::std::fmt::Display,
            {
                self.tick_spacing = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for tick_spacing: {}", e
                        )
                    });
                self
            }
            pub fn token_a_address<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.token_a_address = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for token_a_address: {}", e
                        )
                    });
                self
            }
            pub fn token_a_liquidity<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<
                    ::std::option::Option<super::DexPoolTokenLiquidity>,
                >,
                T::Error: ::std::fmt::Display,
            {
                self.token_a_liquidity = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for token_a_liquidity: {}",
                            e
                        )
                    });
                self
            }
            pub fn token_b_address<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.token_b_address = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for token_b_address: {}", e
                        )
                    });
                self
            }
            pub fn token_b_liquidity<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<
                    ::std::option::Option<super::DexPoolTokenLiquidity>,
                >,
                T::Error: ::std::fmt::Display,
            {
                self.token_b_liquidity = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for token_b_liquidity: {}",
                            e
                        )
                    });
                self
            }
            pub fn token_count<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<i64>>,
                T::Error: ::std::fmt::Display,
            {
                self.token_count = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for token_count: {}", e)
                    });
                self
            }
            pub fn tvl_in_sol<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.tvl_in_sol = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for tvl_in_sol: {}", e)
                    });
                self
            }
            pub fn tvl_in_usd<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.tvl_in_usd = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for tvl_in_usd: {}", e)
                    });
                self
            }
            pub fn type_<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<super::DexPoolDtoType>>,
                T::Error: ::std::fmt::Display,
            {
                self.type_ = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for type_: {}", e)
                    });
                self
            }
            pub fn version<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<
                    ::std::option::Option<super::DexPoolDtoVersion>,
                >,
                T::Error: ::std::fmt::Display,
            {
                self.version = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for version: {}", e)
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<DexPoolDto> for super::DexPoolDto {
            type Error = super::error::ConversionError;
            fn try_from(
                value: DexPoolDto,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    chain: value.chain?,
                    created_block_timestamp: value.created_block_timestamp?,
                    fee_rate: value.fee_rate?,
                    image: value.image?,
                    liquidity_model: value.liquidity_model?,
                    pool_address: value.pool_address?,
                    program_address: value.program_address?,
                    protocol_family: value.protocol_family?,
                    protocol_name: value.protocol_name?,
                    tick_spacing: value.tick_spacing?,
                    token_a_address: value.token_a_address?,
                    token_a_liquidity: value.token_a_liquidity?,
                    token_b_address: value.token_b_address?,
                    token_b_liquidity: value.token_b_liquidity?,
                    token_count: value.token_count?,
                    tvl_in_sol: value.tvl_in_sol?,
                    tvl_in_usd: value.tvl_in_usd?,
                    type_: value.type_?,
                    version: value.version?,
                })
            }
        }
        impl ::std::convert::From<super::DexPoolDto> for DexPoolDto {
            fn from(value: super::DexPoolDto) -> Self {
                Self {
                    chain: Ok(value.chain),
                    created_block_timestamp: Ok(value.created_block_timestamp),
                    fee_rate: Ok(value.fee_rate),
                    image: Ok(value.image),
                    liquidity_model: Ok(value.liquidity_model),
                    pool_address: Ok(value.pool_address),
                    program_address: Ok(value.program_address),
                    protocol_family: Ok(value.protocol_family),
                    protocol_name: Ok(value.protocol_name),
                    tick_spacing: Ok(value.tick_spacing),
                    token_a_address: Ok(value.token_a_address),
                    token_a_liquidity: Ok(value.token_a_liquidity),
                    token_b_address: Ok(value.token_b_address),
                    token_b_liquidity: Ok(value.token_b_liquidity),
                    token_count: Ok(value.token_count),
                    tvl_in_sol: Ok(value.tvl_in_sol),
                    tvl_in_usd: Ok(value.tvl_in_usd),
                    type_: Ok(value.type_),
                    version: Ok(value.version),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct DexPoolPage {
            data: ::std::result::Result<
                ::std::vec::Vec<super::DexPoolDto>,
                ::std::string::String,
            >,
            end_cursor: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            has_next: ::std::result::Result<bool, ::std::string::String>,
            has_prev: ::std::result::Result<bool, ::std::string::String>,
            start_cursor: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            total: ::std::result::Result<i64, ::std::string::String>,
        }
        impl ::std::default::Default for DexPoolPage {
            fn default() -> Self {
                Self {
                    data: Err("no value supplied for data".to_string()),
                    end_cursor: Ok(Default::default()),
                    has_next: Ok(Default::default()),
                    has_prev: Ok(Default::default()),
                    start_cursor: Ok(Default::default()),
                    total: Ok(Default::default()),
                }
            }
        }
        impl DexPoolPage {
            pub fn data<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::vec::Vec<super::DexPoolDto>>,
                T::Error: ::std::fmt::Display,
            {
                self.data = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for data: {}", e)
                    });
                self
            }
            pub fn end_cursor<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.end_cursor = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for end_cursor: {}", e)
                    });
                self
            }
            pub fn has_next<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<bool>,
                T::Error: ::std::fmt::Display,
            {
                self.has_next = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for has_next: {}", e)
                    });
                self
            }
            pub fn has_prev<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<bool>,
                T::Error: ::std::fmt::Display,
            {
                self.has_prev = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for has_prev: {}", e)
                    });
                self
            }
            pub fn start_cursor<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.start_cursor = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for start_cursor: {}", e
                        )
                    });
                self
            }
            pub fn total<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<i64>,
                T::Error: ::std::fmt::Display,
            {
                self.total = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for total: {}", e)
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<DexPoolPage> for super::DexPoolPage {
            type Error = super::error::ConversionError;
            fn try_from(
                value: DexPoolPage,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    data: value.data?,
                    end_cursor: value.end_cursor?,
                    has_next: value.has_next?,
                    has_prev: value.has_prev?,
                    start_cursor: value.start_cursor?,
                    total: value.total?,
                })
            }
        }
        impl ::std::convert::From<super::DexPoolPage> for DexPoolPage {
            fn from(value: super::DexPoolPage) -> Self {
                Self {
                    data: Ok(value.data),
                    end_cursor: Ok(value.end_cursor),
                    has_next: Ok(value.has_next),
                    has_prev: Ok(value.has_prev),
                    start_cursor: Ok(value.start_cursor),
                    total: Ok(value.total),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct DexPoolSnapshotDto {
            block_height: ::std::result::Result<i64, ::std::string::String>,
            block_slot: ::std::result::Result<
                ::std::option::Option<i64>,
                ::std::string::String,
            >,
            block_timestamp: ::std::result::Result<i64, ::std::string::String>,
            pool_address: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            snapshot_time: ::std::result::Result<i64, ::std::string::String>,
            token_a: ::std::result::Result<
                super::DexPoolTokenSnapshotDto,
                ::std::string::String,
            >,
            token_b: ::std::result::Result<
                super::DexPoolTokenSnapshotDto,
                ::std::string::String,
            >,
            tvl_in_native: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            tvl_in_usd: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for DexPoolSnapshotDto {
            fn default() -> Self {
                Self {
                    block_height: Err("no value supplied for block_height".to_string()),
                    block_slot: Ok(Default::default()),
                    block_timestamp: Err(
                        "no value supplied for block_timestamp".to_string(),
                    ),
                    pool_address: Err("no value supplied for pool_address".to_string()),
                    snapshot_time: Err(
                        "no value supplied for snapshot_time".to_string(),
                    ),
                    token_a: Err("no value supplied for token_a".to_string()),
                    token_b: Err("no value supplied for token_b".to_string()),
                    tvl_in_native: Err(
                        "no value supplied for tvl_in_native".to_string(),
                    ),
                    tvl_in_usd: Err("no value supplied for tvl_in_usd".to_string()),
                }
            }
        }
        impl DexPoolSnapshotDto {
            pub fn block_height<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<i64>,
                T::Error: ::std::fmt::Display,
            {
                self.block_height = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for block_height: {}", e
                        )
                    });
                self
            }
            pub fn block_slot<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<i64>>,
                T::Error: ::std::fmt::Display,
            {
                self.block_slot = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for block_slot: {}", e)
                    });
                self
            }
            pub fn block_timestamp<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<i64>,
                T::Error: ::std::fmt::Display,
            {
                self.block_timestamp = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for block_timestamp: {}", e
                        )
                    });
                self
            }
            pub fn pool_address<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.pool_address = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for pool_address: {}", e
                        )
                    });
                self
            }
            pub fn snapshot_time<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<i64>,
                T::Error: ::std::fmt::Display,
            {
                self.snapshot_time = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for snapshot_time: {}", e
                        )
                    });
                self
            }
            pub fn token_a<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<super::DexPoolTokenSnapshotDto>,
                T::Error: ::std::fmt::Display,
            {
                self.token_a = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for token_a: {}", e)
                    });
                self
            }
            pub fn token_b<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<super::DexPoolTokenSnapshotDto>,
                T::Error: ::std::fmt::Display,
            {
                self.token_b = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for token_b: {}", e)
                    });
                self
            }
            pub fn tvl_in_native<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.tvl_in_native = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for tvl_in_native: {}", e
                        )
                    });
                self
            }
            pub fn tvl_in_usd<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.tvl_in_usd = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for tvl_in_usd: {}", e)
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<DexPoolSnapshotDto> for super::DexPoolSnapshotDto {
            type Error = super::error::ConversionError;
            fn try_from(
                value: DexPoolSnapshotDto,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    block_height: value.block_height?,
                    block_slot: value.block_slot?,
                    block_timestamp: value.block_timestamp?,
                    pool_address: value.pool_address?,
                    snapshot_time: value.snapshot_time?,
                    token_a: value.token_a?,
                    token_b: value.token_b?,
                    tvl_in_native: value.tvl_in_native?,
                    tvl_in_usd: value.tvl_in_usd?,
                })
            }
        }
        impl ::std::convert::From<super::DexPoolSnapshotDto> for DexPoolSnapshotDto {
            fn from(value: super::DexPoolSnapshotDto) -> Self {
                Self {
                    block_height: Ok(value.block_height),
                    block_slot: Ok(value.block_slot),
                    block_timestamp: Ok(value.block_timestamp),
                    pool_address: Ok(value.pool_address),
                    snapshot_time: Ok(value.snapshot_time),
                    token_a: Ok(value.token_a),
                    token_b: Ok(value.token_b),
                    tvl_in_native: Ok(value.tvl_in_native),
                    tvl_in_usd: Ok(value.tvl_in_usd),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct DexPoolSnapshotPage {
            data: ::std::result::Result<
                ::std::vec::Vec<super::DexPoolSnapshotDto>,
                ::std::string::String,
            >,
            end_cursor: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            has_next: ::std::result::Result<bool, ::std::string::String>,
            has_prev: ::std::result::Result<bool, ::std::string::String>,
            start_cursor: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for DexPoolSnapshotPage {
            fn default() -> Self {
                Self {
                    data: Err("no value supplied for data".to_string()),
                    end_cursor: Ok(Default::default()),
                    has_next: Err("no value supplied for has_next".to_string()),
                    has_prev: Err("no value supplied for has_prev".to_string()),
                    start_cursor: Ok(Default::default()),
                }
            }
        }
        impl DexPoolSnapshotPage {
            pub fn data<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::vec::Vec<super::DexPoolSnapshotDto>>,
                T::Error: ::std::fmt::Display,
            {
                self.data = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for data: {}", e)
                    });
                self
            }
            pub fn end_cursor<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.end_cursor = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for end_cursor: {}", e)
                    });
                self
            }
            pub fn has_next<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<bool>,
                T::Error: ::std::fmt::Display,
            {
                self.has_next = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for has_next: {}", e)
                    });
                self
            }
            pub fn has_prev<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<bool>,
                T::Error: ::std::fmt::Display,
            {
                self.has_prev = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for has_prev: {}", e)
                    });
                self
            }
            pub fn start_cursor<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.start_cursor = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for start_cursor: {}", e
                        )
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<DexPoolSnapshotPage>
        for super::DexPoolSnapshotPage {
            type Error = super::error::ConversionError;
            fn try_from(
                value: DexPoolSnapshotPage,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    data: value.data?,
                    end_cursor: value.end_cursor?,
                    has_next: value.has_next?,
                    has_prev: value.has_prev?,
                    start_cursor: value.start_cursor?,
                })
            }
        }
        impl ::std::convert::From<super::DexPoolSnapshotPage> for DexPoolSnapshotPage {
            fn from(value: super::DexPoolSnapshotPage) -> Self {
                Self {
                    data: Ok(value.data),
                    end_cursor: Ok(value.end_cursor),
                    has_next: Ok(value.has_next),
                    has_prev: Ok(value.has_prev),
                    start_cursor: Ok(value.start_cursor),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct DexPoolTokenLiquidity {
            amount_in_native: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            amount_in_usd: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            decimals: ::std::result::Result<i64, ::std::string::String>,
            price_native: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            price_usd: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            token_address: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            vault_amount: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for DexPoolTokenLiquidity {
            fn default() -> Self {
                Self {
                    amount_in_native: Err(
                        "no value supplied for amount_in_native".to_string(),
                    ),
                    amount_in_usd: Err(
                        "no value supplied for amount_in_usd".to_string(),
                    ),
                    decimals: Err("no value supplied for decimals".to_string()),
                    price_native: Err("no value supplied for price_native".to_string()),
                    price_usd: Err("no value supplied for price_usd".to_string()),
                    token_address: Err(
                        "no value supplied for token_address".to_string(),
                    ),
                    vault_amount: Err("no value supplied for vault_amount".to_string()),
                }
            }
        }
        impl DexPoolTokenLiquidity {
            pub fn amount_in_native<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.amount_in_native = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for amount_in_native: {}", e
                        )
                    });
                self
            }
            pub fn amount_in_usd<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.amount_in_usd = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for amount_in_usd: {}", e
                        )
                    });
                self
            }
            pub fn decimals<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<i64>,
                T::Error: ::std::fmt::Display,
            {
                self.decimals = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for decimals: {}", e)
                    });
                self
            }
            pub fn price_native<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.price_native = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for price_native: {}", e
                        )
                    });
                self
            }
            pub fn price_usd<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.price_usd = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for price_usd: {}", e)
                    });
                self
            }
            pub fn token_address<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.token_address = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for token_address: {}", e
                        )
                    });
                self
            }
            pub fn vault_amount<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.vault_amount = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for vault_amount: {}", e
                        )
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<DexPoolTokenLiquidity>
        for super::DexPoolTokenLiquidity {
            type Error = super::error::ConversionError;
            fn try_from(
                value: DexPoolTokenLiquidity,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    amount_in_native: value.amount_in_native?,
                    amount_in_usd: value.amount_in_usd?,
                    decimals: value.decimals?,
                    price_native: value.price_native?,
                    price_usd: value.price_usd?,
                    token_address: value.token_address?,
                    vault_amount: value.vault_amount?,
                })
            }
        }
        impl ::std::convert::From<super::DexPoolTokenLiquidity>
        for DexPoolTokenLiquidity {
            fn from(value: super::DexPoolTokenLiquidity) -> Self {
                Self {
                    amount_in_native: Ok(value.amount_in_native),
                    amount_in_usd: Ok(value.amount_in_usd),
                    decimals: Ok(value.decimals),
                    price_native: Ok(value.price_native),
                    price_usd: Ok(value.price_usd),
                    token_address: Ok(value.token_address),
                    vault_amount: Ok(value.vault_amount),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct DexPoolTokenSnapshotDto {
            amount_in_native: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            amount_in_usd: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            decimals: ::std::result::Result<i64, ::std::string::String>,
            price_native: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            price_usd: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            token_address: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            vault_amount: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for DexPoolTokenSnapshotDto {
            fn default() -> Self {
                Self {
                    amount_in_native: Err(
                        "no value supplied for amount_in_native".to_string(),
                    ),
                    amount_in_usd: Err(
                        "no value supplied for amount_in_usd".to_string(),
                    ),
                    decimals: Err("no value supplied for decimals".to_string()),
                    price_native: Err("no value supplied for price_native".to_string()),
                    price_usd: Err("no value supplied for price_usd".to_string()),
                    token_address: Err(
                        "no value supplied for token_address".to_string(),
                    ),
                    vault_amount: Err("no value supplied for vault_amount".to_string()),
                }
            }
        }
        impl DexPoolTokenSnapshotDto {
            pub fn amount_in_native<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.amount_in_native = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for amount_in_native: {}", e
                        )
                    });
                self
            }
            pub fn amount_in_usd<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.amount_in_usd = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for amount_in_usd: {}", e
                        )
                    });
                self
            }
            pub fn decimals<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<i64>,
                T::Error: ::std::fmt::Display,
            {
                self.decimals = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for decimals: {}", e)
                    });
                self
            }
            pub fn price_native<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.price_native = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for price_native: {}", e
                        )
                    });
                self
            }
            pub fn price_usd<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.price_usd = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for price_usd: {}", e)
                    });
                self
            }
            pub fn token_address<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.token_address = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for token_address: {}", e
                        )
                    });
                self
            }
            pub fn vault_amount<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.vault_amount = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for vault_amount: {}", e
                        )
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<DexPoolTokenSnapshotDto>
        for super::DexPoolTokenSnapshotDto {
            type Error = super::error::ConversionError;
            fn try_from(
                value: DexPoolTokenSnapshotDto,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    amount_in_native: value.amount_in_native?,
                    amount_in_usd: value.amount_in_usd?,
                    decimals: value.decimals?,
                    price_native: value.price_native?,
                    price_usd: value.price_usd?,
                    token_address: value.token_address?,
                    vault_amount: value.vault_amount?,
                })
            }
        }
        impl ::std::convert::From<super::DexPoolTokenSnapshotDto>
        for DexPoolTokenSnapshotDto {
            fn from(value: super::DexPoolTokenSnapshotDto) -> Self {
                Self {
                    amount_in_native: Ok(value.amount_in_native),
                    amount_in_usd: Ok(value.amount_in_usd),
                    decimals: Ok(value.decimals),
                    price_native: Ok(value.price_native),
                    price_usd: Ok(value.price_usd),
                    token_address: Ok(value.token_address),
                    vault_amount: Ok(value.vault_amount),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct DexQuoteResponse {
            amount_out: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            current_price: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            execution_price: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            fee: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            min_amount_out: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            price_impact: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for DexQuoteResponse {
            fn default() -> Self {
                Self {
                    amount_out: Ok(Default::default()),
                    current_price: Ok(Default::default()),
                    execution_price: Ok(Default::default()),
                    fee: Ok(Default::default()),
                    min_amount_out: Ok(Default::default()),
                    price_impact: Ok(Default::default()),
                }
            }
        }
        impl DexQuoteResponse {
            pub fn amount_out<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.amount_out = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for amount_out: {}", e)
                    });
                self
            }
            pub fn current_price<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.current_price = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for current_price: {}", e
                        )
                    });
                self
            }
            pub fn execution_price<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.execution_price = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for execution_price: {}", e
                        )
                    });
                self
            }
            pub fn fee<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.fee = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for fee: {}", e)
                    });
                self
            }
            pub fn min_amount_out<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.min_amount_out = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for min_amount_out: {}", e
                        )
                    });
                self
            }
            pub fn price_impact<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.price_impact = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for price_impact: {}", e
                        )
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<DexQuoteResponse> for super::DexQuoteResponse {
            type Error = super::error::ConversionError;
            fn try_from(
                value: DexQuoteResponse,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    amount_out: value.amount_out?,
                    current_price: value.current_price?,
                    execution_price: value.execution_price?,
                    fee: value.fee?,
                    min_amount_out: value.min_amount_out?,
                    price_impact: value.price_impact?,
                })
            }
        }
        impl ::std::convert::From<super::DexQuoteResponse> for DexQuoteResponse {
            fn from(value: super::DexQuoteResponse) -> Self {
                Self {
                    amount_out: Ok(value.amount_out),
                    current_price: Ok(value.current_price),
                    execution_price: Ok(value.execution_price),
                    fee: Ok(value.fee),
                    min_amount_out: Ok(value.min_amount_out),
                    price_impact: Ok(value.price_impact),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct DirectExposureDetail {
            category_id: ::std::result::Result<i64, ::std::string::String>,
            name: ::std::result::Result<::std::string::String, ::std::string::String>,
        }
        impl ::std::default::Default for DirectExposureDetail {
            fn default() -> Self {
                Self {
                    category_id: Err("no value supplied for category_id".to_string()),
                    name: Err("no value supplied for name".to_string()),
                }
            }
        }
        impl DirectExposureDetail {
            pub fn category_id<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<i64>,
                T::Error: ::std::fmt::Display,
            {
                self.category_id = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for category_id: {}", e)
                    });
                self
            }
            pub fn name<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.name = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for name: {}", e)
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<DirectExposureDetail>
        for super::DirectExposureDetail {
            type Error = super::error::ConversionError;
            fn try_from(
                value: DirectExposureDetail,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    category_id: value.category_id?,
                    name: value.name?,
                })
            }
        }
        impl ::std::convert::From<super::DirectExposureDetail> for DirectExposureDetail {
            fn from(value: super::DirectExposureDetail) -> Self {
                Self {
                    category_id: Ok(value.category_id),
                    name: Ok(value.name),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct EndpointListResponse {
            data: ::std::result::Result<
                ::std::vec::Vec<super::EndpointResponse>,
                ::std::string::String,
            >,
            done: ::std::result::Result<
                ::std::option::Option<bool>,
                ::std::string::String,
            >,
            iterator: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            prev_iterator: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for EndpointListResponse {
            fn default() -> Self {
                Self {
                    data: Ok(Default::default()),
                    done: Ok(Default::default()),
                    iterator: Ok(Default::default()),
                    prev_iterator: Ok(Default::default()),
                }
            }
        }
        impl EndpointListResponse {
            pub fn data<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::vec::Vec<super::EndpointResponse>>,
                T::Error: ::std::fmt::Display,
            {
                self.data = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for data: {}", e)
                    });
                self
            }
            pub fn done<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<bool>>,
                T::Error: ::std::fmt::Display,
            {
                self.done = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for done: {}", e)
                    });
                self
            }
            pub fn iterator<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.iterator = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for iterator: {}", e)
                    });
                self
            }
            pub fn prev_iterator<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.prev_iterator = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for prev_iterator: {}", e
                        )
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<EndpointListResponse>
        for super::EndpointListResponse {
            type Error = super::error::ConversionError;
            fn try_from(
                value: EndpointListResponse,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    data: value.data?,
                    done: value.done?,
                    iterator: value.iterator?,
                    prev_iterator: value.prev_iterator?,
                })
            }
        }
        impl ::std::convert::From<super::EndpointListResponse> for EndpointListResponse {
            fn from(value: super::EndpointListResponse) -> Self {
                Self {
                    data: Ok(value.data),
                    done: Ok(value.done),
                    iterator: Ok(value.iterator),
                    prev_iterator: Ok(value.prev_iterator),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct EndpointOperationResponse {
            success: ::std::result::Result<
                ::std::option::Option<bool>,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for EndpointOperationResponse {
            fn default() -> Self {
                Self {
                    success: Ok(Default::default()),
                }
            }
        }
        impl EndpointOperationResponse {
            pub fn success<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<bool>>,
                T::Error: ::std::fmt::Display,
            {
                self.success = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for success: {}", e)
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<EndpointOperationResponse>
        for super::EndpointOperationResponse {
            type Error = super::error::ConversionError;
            fn try_from(
                value: EndpointOperationResponse,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self { success: value.success? })
            }
        }
        impl ::std::convert::From<super::EndpointOperationResponse>
        for EndpointOperationResponse {
            fn from(value: super::EndpointOperationResponse) -> Self {
                Self { success: Ok(value.success) }
            }
        }
        #[derive(Clone, Debug)]
        pub struct EndpointResponse {
            channels: ::std::result::Result<
                ::std::vec::Vec<super::EndpointResponseChannelsItem>,
                ::std::string::String,
            >,
            created_at: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            description: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            disabled: ::std::result::Result<
                ::std::option::Option<bool>,
                ::std::string::String,
            >,
            filter: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            filter_types: ::std::result::Result<
                ::std::vec::Vec<::std::string::String>,
                ::std::string::String,
            >,
            id: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            metadata: ::std::result::Result<
                ::serde_json::Map<::std::string::String, ::serde_json::Value>,
                ::std::string::String,
            >,
            rate_limit: ::std::result::Result<
                ::std::option::Option<i64>,
                ::std::string::String,
            >,
            updated_at: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            url: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for EndpointResponse {
            fn default() -> Self {
                Self {
                    channels: Ok(Default::default()),
                    created_at: Ok(Default::default()),
                    description: Ok(Default::default()),
                    disabled: Ok(Default::default()),
                    filter: Ok(Default::default()),
                    filter_types: Ok(Default::default()),
                    id: Ok(Default::default()),
                    metadata: Ok(Default::default()),
                    rate_limit: Ok(Default::default()),
                    updated_at: Ok(Default::default()),
                    url: Ok(Default::default()),
                }
            }
        }
        impl EndpointResponse {
            pub fn channels<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<
                    ::std::vec::Vec<super::EndpointResponseChannelsItem>,
                >,
                T::Error: ::std::fmt::Display,
            {
                self.channels = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for channels: {}", e)
                    });
                self
            }
            pub fn created_at<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.created_at = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for created_at: {}", e)
                    });
                self
            }
            pub fn description<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.description = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for description: {}", e)
                    });
                self
            }
            pub fn disabled<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<bool>>,
                T::Error: ::std::fmt::Display,
            {
                self.disabled = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for disabled: {}", e)
                    });
                self
            }
            pub fn filter<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.filter = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for filter: {}", e)
                    });
                self
            }
            pub fn filter_types<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::vec::Vec<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.filter_types = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for filter_types: {}", e
                        )
                    });
                self
            }
            pub fn id<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.id = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for id: {}", e)
                    });
                self
            }
            pub fn metadata<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<
                    ::serde_json::Map<::std::string::String, ::serde_json::Value>,
                >,
                T::Error: ::std::fmt::Display,
            {
                self.metadata = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for metadata: {}", e)
                    });
                self
            }
            pub fn rate_limit<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<i64>>,
                T::Error: ::std::fmt::Display,
            {
                self.rate_limit = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for rate_limit: {}", e)
                    });
                self
            }
            pub fn updated_at<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.updated_at = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for updated_at: {}", e)
                    });
                self
            }
            pub fn url<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.url = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for url: {}", e)
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<EndpointResponse> for super::EndpointResponse {
            type Error = super::error::ConversionError;
            fn try_from(
                value: EndpointResponse,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    channels: value.channels?,
                    created_at: value.created_at?,
                    description: value.description?,
                    disabled: value.disabled?,
                    filter: value.filter?,
                    filter_types: value.filter_types?,
                    id: value.id?,
                    metadata: value.metadata?,
                    rate_limit: value.rate_limit?,
                    updated_at: value.updated_at?,
                    url: value.url?,
                })
            }
        }
        impl ::std::convert::From<super::EndpointResponse> for EndpointResponse {
            fn from(value: super::EndpointResponse) -> Self {
                Self {
                    channels: Ok(value.channels),
                    created_at: Ok(value.created_at),
                    description: Ok(value.description),
                    disabled: Ok(value.disabled),
                    filter: Ok(value.filter),
                    filter_types: Ok(value.filter_types),
                    id: Ok(value.id),
                    metadata: Ok(value.metadata),
                    rate_limit: Ok(value.rate_limit),
                    updated_at: Ok(value.updated_at),
                    url: Ok(value.url),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct EndpointSecretResponse {
            secret: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for EndpointSecretResponse {
            fn default() -> Self {
                Self {
                    secret: Ok(Default::default()),
                }
            }
        }
        impl EndpointSecretResponse {
            pub fn secret<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.secret = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for secret: {}", e)
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<EndpointSecretResponse>
        for super::EndpointSecretResponse {
            type Error = super::error::ConversionError;
            fn try_from(
                value: EndpointSecretResponse,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self { secret: value.secret? })
            }
        }
        impl ::std::convert::From<super::EndpointSecretResponse>
        for EndpointSecretResponse {
            fn from(value: super::EndpointSecretResponse) -> Self {
                Self { secret: Ok(value.secret) }
            }
        }
        #[derive(Clone, Debug)]
        pub struct EstimateGasLimitInput {
            data: ::std::result::Result<::std::string::String, ::std::string::String>,
            from: ::std::result::Result<::std::string::String, ::std::string::String>,
            to: ::std::result::Result<::std::string::String, ::std::string::String>,
            value: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for EstimateGasLimitInput {
            fn default() -> Self {
                Self {
                    data: Err("no value supplied for data".to_string()),
                    from: Err("no value supplied for from".to_string()),
                    to: Err("no value supplied for to".to_string()),
                    value: Ok(Default::default()),
                }
            }
        }
        impl EstimateGasLimitInput {
            pub fn data<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.data = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for data: {}", e)
                    });
                self
            }
            pub fn from<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.from = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for from: {}", e)
                    });
                self
            }
            pub fn to<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.to = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for to: {}", e)
                    });
                self
            }
            pub fn value<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.value = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for value: {}", e)
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<EstimateGasLimitInput>
        for super::EstimateGasLimitInput {
            type Error = super::error::ConversionError;
            fn try_from(
                value: EstimateGasLimitInput,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    data: value.data?,
                    from: value.from?,
                    to: value.to?,
                    value: value.value?,
                })
            }
        }
        impl ::std::convert::From<super::EstimateGasLimitInput>
        for EstimateGasLimitInput {
            fn from(value: super::EstimateGasLimitInput) -> Self {
                Self {
                    data: Ok(value.data),
                    from: Ok(value.from),
                    to: Ok(value.to),
                    value: Ok(value.value),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct EstimateGasLimitResponse {
            chain: ::std::result::Result<::std::string::String, ::std::string::String>,
            gas_limit: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for EstimateGasLimitResponse {
            fn default() -> Self {
                Self {
                    chain: Err("no value supplied for chain".to_string()),
                    gas_limit: Err("no value supplied for gas_limit".to_string()),
                }
            }
        }
        impl EstimateGasLimitResponse {
            pub fn chain<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.chain = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for chain: {}", e)
                    });
                self
            }
            pub fn gas_limit<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.gas_limit = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for gas_limit: {}", e)
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<EstimateGasLimitResponse>
        for super::EstimateGasLimitResponse {
            type Error = super::error::ConversionError;
            fn try_from(
                value: EstimateGasLimitResponse,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    chain: value.chain?,
                    gas_limit: value.gas_limit?,
                })
            }
        }
        impl ::std::convert::From<super::EstimateGasLimitResponse>
        for EstimateGasLimitResponse {
            fn from(value: super::EstimateGasLimitResponse) -> Self {
                Self {
                    chain: Ok(value.chain),
                    gas_limit: Ok(value.gas_limit),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct FilterCondition {
            field: ::std::result::Result<
                ::std::option::Option<super::FilterConditionField>,
                ::std::string::String,
            >,
            max: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            min: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for FilterCondition {
            fn default() -> Self {
                Self {
                    field: Ok(Default::default()),
                    max: Ok(Default::default()),
                    min: Ok(Default::default()),
                }
            }
        }
        impl FilterCondition {
            pub fn field<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<
                    ::std::option::Option<super::FilterConditionField>,
                >,
                T::Error: ::std::fmt::Display,
            {
                self.field = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for field: {}", e)
                    });
                self
            }
            pub fn max<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.max = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for max: {}", e)
                    });
                self
            }
            pub fn min<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.min = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for min: {}", e)
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<FilterCondition> for super::FilterCondition {
            type Error = super::error::ConversionError;
            fn try_from(
                value: FilterCondition,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    field: value.field?,
                    max: value.max?,
                    min: value.min?,
                })
            }
        }
        impl ::std::convert::From<super::FilterCondition> for FilterCondition {
            fn from(value: super::FilterCondition) -> Self {
                Self {
                    field: Ok(value.field),
                    max: Ok(value.max),
                    min: Ok(value.min),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct GasPriceResponse {
            chain: ::std::result::Result<::std::string::String, ::std::string::String>,
            gas_price: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for GasPriceResponse {
            fn default() -> Self {
                Self {
                    chain: Err("no value supplied for chain".to_string()),
                    gas_price: Err("no value supplied for gas_price".to_string()),
                }
            }
        }
        impl GasPriceResponse {
            pub fn chain<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.chain = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for chain: {}", e)
                    });
                self
            }
            pub fn gas_price<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.gas_price = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for gas_price: {}", e)
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<GasPriceResponse> for super::GasPriceResponse {
            type Error = super::error::ConversionError;
            fn try_from(
                value: GasPriceResponse,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    chain: value.chain?,
                    gas_price: value.gas_price?,
                })
            }
        }
        impl ::std::convert::From<super::GasPriceResponse> for GasPriceResponse {
            fn from(value: super::GasPriceResponse) -> Self {
                Self {
                    chain: Ok(value.chain),
                    gas_price: Ok(value.gas_price),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct JobDto {
            result: ::std::result::Result<
                ::serde_json::Map<::std::string::String, ::serde_json::Value>,
                ::std::string::String,
            >,
            state: ::std::result::Result<::std::string::String, ::std::string::String>,
        }
        impl ::std::default::Default for JobDto {
            fn default() -> Self {
                Self {
                    result: Err("no value supplied for result".to_string()),
                    state: Err("no value supplied for state".to_string()),
                }
            }
        }
        impl JobDto {
            pub fn result<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<
                    ::serde_json::Map<::std::string::String, ::serde_json::Value>,
                >,
                T::Error: ::std::fmt::Display,
            {
                self.result = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for result: {}", e)
                    });
                self
            }
            pub fn state<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.state = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for state: {}", e)
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<JobDto> for super::JobDto {
            type Error = super::error::ConversionError;
            fn try_from(
                value: JobDto,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    result: value.result?,
                    state: value.state?,
                })
            }
        }
        impl ::std::convert::From<super::JobDto> for JobDto {
            fn from(value: super::JobDto) -> Self {
                Self {
                    result: Ok(value.result),
                    state: Ok(value.state),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct JobStreamingDto {
            data: ::std::result::Result<
                ::serde_json::Map<::std::string::String, ::serde_json::Value>,
                ::std::string::String,
            >,
            id: ::std::result::Result<f64, ::std::string::String>,
        }
        impl ::std::default::Default for JobStreamingDto {
            fn default() -> Self {
                Self {
                    data: Err("no value supplied for data".to_string()),
                    id: Err("no value supplied for id".to_string()),
                }
            }
        }
        impl JobStreamingDto {
            pub fn data<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<
                    ::serde_json::Map<::std::string::String, ::serde_json::Value>,
                >,
                T::Error: ::std::fmt::Display,
            {
                self.data = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for data: {}", e)
                    });
                self
            }
            pub fn id<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<f64>,
                T::Error: ::std::fmt::Display,
            {
                self.id = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for id: {}", e)
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<JobStreamingDto> for super::JobStreamingDto {
            type Error = super::error::ConversionError;
            fn try_from(
                value: JobStreamingDto,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    data: value.data?,
                    id: value.id?,
                })
            }
        }
        impl ::std::convert::From<super::JobStreamingDto> for JobStreamingDto {
            fn from(value: super::JobStreamingDto) -> Self {
                Self {
                    data: Ok(value.data),
                    id: Ok(value.id),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct KytRegisterTransferRequest {
            asset: ::std::result::Result<::std::string::String, ::std::string::String>,
            direction: ::std::result::Result<
                super::KytRegisterTransferRequestDirection,
                ::std::string::String,
            >,
            network: ::std::result::Result<
                super::KytRegisterTransferRequestNetwork,
                ::std::string::String,
            >,
            transfer_reference: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for KytRegisterTransferRequest {
            fn default() -> Self {
                Self {
                    asset: Err("no value supplied for asset".to_string()),
                    direction: Err("no value supplied for direction".to_string()),
                    network: Err("no value supplied for network".to_string()),
                    transfer_reference: Err(
                        "no value supplied for transfer_reference".to_string(),
                    ),
                }
            }
        }
        impl KytRegisterTransferRequest {
            pub fn asset<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.asset = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for asset: {}", e)
                    });
                self
            }
            pub fn direction<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<super::KytRegisterTransferRequestDirection>,
                T::Error: ::std::fmt::Display,
            {
                self.direction = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for direction: {}", e)
                    });
                self
            }
            pub fn network<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<super::KytRegisterTransferRequestNetwork>,
                T::Error: ::std::fmt::Display,
            {
                self.network = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for network: {}", e)
                    });
                self
            }
            pub fn transfer_reference<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.transfer_reference = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for transfer_reference: {}",
                            e
                        )
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<KytRegisterTransferRequest>
        for super::KytRegisterTransferRequest {
            type Error = super::error::ConversionError;
            fn try_from(
                value: KytRegisterTransferRequest,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    asset: value.asset?,
                    direction: value.direction?,
                    network: value.network?,
                    transfer_reference: value.transfer_reference?,
                })
            }
        }
        impl ::std::convert::From<super::KytRegisterTransferRequest>
        for KytRegisterTransferRequest {
            fn from(value: super::KytRegisterTransferRequest) -> Self {
                Self {
                    asset: Ok(value.asset),
                    direction: Ok(value.direction),
                    network: Ok(value.network),
                    transfer_reference: Ok(value.transfer_reference),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct KytRegisterWithdrawalRequest {
            address: ::std::result::Result<::std::string::String, ::std::string::String>,
            asset: ::std::result::Result<::std::string::String, ::std::string::String>,
            asset_amount: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            asset_denomination: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            asset_id: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            asset_price: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            attempt_timestamp: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            memo: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            network: ::std::result::Result<
                super::KytRegisterWithdrawalRequestNetwork,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for KytRegisterWithdrawalRequest {
            fn default() -> Self {
                Self {
                    address: Err("no value supplied for address".to_string()),
                    asset: Err("no value supplied for asset".to_string()),
                    asset_amount: Err("no value supplied for asset_amount".to_string()),
                    asset_denomination: Ok(Default::default()),
                    asset_id: Ok(Default::default()),
                    asset_price: Ok(Default::default()),
                    attempt_timestamp: Err(
                        "no value supplied for attempt_timestamp".to_string(),
                    ),
                    memo: Ok(Default::default()),
                    network: Err("no value supplied for network".to_string()),
                }
            }
        }
        impl KytRegisterWithdrawalRequest {
            pub fn address<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.address = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for address: {}", e)
                    });
                self
            }
            pub fn asset<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.asset = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for asset: {}", e)
                    });
                self
            }
            pub fn asset_amount<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.asset_amount = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for asset_amount: {}", e
                        )
                    });
                self
            }
            pub fn asset_denomination<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.asset_denomination = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for asset_denomination: {}",
                            e
                        )
                    });
                self
            }
            pub fn asset_id<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.asset_id = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for asset_id: {}", e)
                    });
                self
            }
            pub fn asset_price<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.asset_price = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for asset_price: {}", e)
                    });
                self
            }
            pub fn attempt_timestamp<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.attempt_timestamp = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for attempt_timestamp: {}",
                            e
                        )
                    });
                self
            }
            pub fn memo<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.memo = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for memo: {}", e)
                    });
                self
            }
            pub fn network<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<super::KytRegisterWithdrawalRequestNetwork>,
                T::Error: ::std::fmt::Display,
            {
                self.network = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for network: {}", e)
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<KytRegisterWithdrawalRequest>
        for super::KytRegisterWithdrawalRequest {
            type Error = super::error::ConversionError;
            fn try_from(
                value: KytRegisterWithdrawalRequest,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    address: value.address?,
                    asset: value.asset?,
                    asset_amount: value.asset_amount?,
                    asset_denomination: value.asset_denomination?,
                    asset_id: value.asset_id?,
                    asset_price: value.asset_price?,
                    attempt_timestamp: value.attempt_timestamp?,
                    memo: value.memo?,
                    network: value.network?,
                })
            }
        }
        impl ::std::convert::From<super::KytRegisterWithdrawalRequest>
        for KytRegisterWithdrawalRequest {
            fn from(value: super::KytRegisterWithdrawalRequest) -> Self {
                Self {
                    address: Ok(value.address),
                    asset: Ok(value.asset),
                    asset_amount: Ok(value.asset_amount),
                    asset_denomination: Ok(value.asset_denomination),
                    asset_id: Ok(value.asset_id),
                    asset_price: Ok(value.asset_price),
                    attempt_timestamp: Ok(value.attempt_timestamp),
                    memo: Ok(value.memo),
                    network: Ok(value.network),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct Link {
            label: ::std::result::Result<super::LinkLabel, ::std::string::String>,
            url: ::std::result::Result<::std::string::String, ::std::string::String>,
        }
        impl ::std::default::Default for Link {
            fn default() -> Self {
                Self {
                    label: Err("no value supplied for label".to_string()),
                    url: Err("no value supplied for url".to_string()),
                }
            }
        }
        impl Link {
            pub fn label<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<super::LinkLabel>,
                T::Error: ::std::fmt::Display,
            {
                self.label = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for label: {}", e)
                    });
                self
            }
            pub fn url<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.url = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for url: {}", e)
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<Link> for super::Link {
            type Error = super::error::ConversionError;
            fn try_from(
                value: Link,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    label: value.label?,
                    url: value.url?,
                })
            }
        }
        impl ::std::convert::From<super::Link> for Link {
            fn from(value: super::Link) -> Self {
                Self {
                    label: Ok(value.label),
                    url: Ok(value.url),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct MoonshotCreateTokenInput {
            banner: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            description: ::std::result::Result<
                super::MoonshotCreateTokenInputDescription,
                ::std::string::String,
            >,
            dex: ::std::result::Result<
                super::MoonshotCreateTokenInputDex,
                ::std::string::String,
            >,
            icon: ::std::result::Result<
                super::MoonshotCreateTokenInputIcon,
                ::std::string::String,
            >,
            links: ::std::result::Result<
                ::std::vec::Vec<super::Link>,
                ::std::string::String,
            >,
            migration_dex: ::std::result::Result<
                super::MoonshotCreateTokenInputMigrationDex,
                ::std::string::String,
            >,
            name: ::std::result::Result<
                super::MoonshotCreateTokenInputName,
                ::std::string::String,
            >,
            priority_fee: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            symbol: ::std::result::Result<
                super::MoonshotCreateTokenInputSymbol,
                ::std::string::String,
            >,
            token_amount: ::std::result::Result<
                super::MoonshotCreateTokenInputTokenAmount,
                ::std::string::String,
            >,
            user_address: ::std::result::Result<
                super::MoonshotCreateTokenInputUserAddress,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for MoonshotCreateTokenInput {
            fn default() -> Self {
                Self {
                    banner: Ok(Default::default()),
                    description: Err("no value supplied for description".to_string()),
                    dex: Err("no value supplied for dex".to_string()),
                    icon: Err("no value supplied for icon".to_string()),
                    links: Err("no value supplied for links".to_string()),
                    migration_dex: Err(
                        "no value supplied for migration_dex".to_string(),
                    ),
                    name: Err("no value supplied for name".to_string()),
                    priority_fee: Ok(Default::default()),
                    symbol: Err("no value supplied for symbol".to_string()),
                    token_amount: Err("no value supplied for token_amount".to_string()),
                    user_address: Err("no value supplied for user_address".to_string()),
                }
            }
        }
        impl MoonshotCreateTokenInput {
            pub fn banner<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.banner = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for banner: {}", e)
                    });
                self
            }
            pub fn description<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<super::MoonshotCreateTokenInputDescription>,
                T::Error: ::std::fmt::Display,
            {
                self.description = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for description: {}", e)
                    });
                self
            }
            pub fn dex<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<super::MoonshotCreateTokenInputDex>,
                T::Error: ::std::fmt::Display,
            {
                self.dex = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for dex: {}", e)
                    });
                self
            }
            pub fn icon<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<super::MoonshotCreateTokenInputIcon>,
                T::Error: ::std::fmt::Display,
            {
                self.icon = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for icon: {}", e)
                    });
                self
            }
            pub fn links<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::vec::Vec<super::Link>>,
                T::Error: ::std::fmt::Display,
            {
                self.links = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for links: {}", e)
                    });
                self
            }
            pub fn migration_dex<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<super::MoonshotCreateTokenInputMigrationDex>,
                T::Error: ::std::fmt::Display,
            {
                self.migration_dex = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for migration_dex: {}", e
                        )
                    });
                self
            }
            pub fn name<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<super::MoonshotCreateTokenInputName>,
                T::Error: ::std::fmt::Display,
            {
                self.name = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for name: {}", e)
                    });
                self
            }
            pub fn priority_fee<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.priority_fee = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for priority_fee: {}", e
                        )
                    });
                self
            }
            pub fn symbol<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<super::MoonshotCreateTokenInputSymbol>,
                T::Error: ::std::fmt::Display,
            {
                self.symbol = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for symbol: {}", e)
                    });
                self
            }
            pub fn token_amount<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<super::MoonshotCreateTokenInputTokenAmount>,
                T::Error: ::std::fmt::Display,
            {
                self.token_amount = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for token_amount: {}", e
                        )
                    });
                self
            }
            pub fn user_address<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<super::MoonshotCreateTokenInputUserAddress>,
                T::Error: ::std::fmt::Display,
            {
                self.user_address = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for user_address: {}", e
                        )
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<MoonshotCreateTokenInput>
        for super::MoonshotCreateTokenInput {
            type Error = super::error::ConversionError;
            fn try_from(
                value: MoonshotCreateTokenInput,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    banner: value.banner?,
                    description: value.description?,
                    dex: value.dex?,
                    icon: value.icon?,
                    links: value.links?,
                    migration_dex: value.migration_dex?,
                    name: value.name?,
                    priority_fee: value.priority_fee?,
                    symbol: value.symbol?,
                    token_amount: value.token_amount?,
                    user_address: value.user_address?,
                })
            }
        }
        impl ::std::convert::From<super::MoonshotCreateTokenInput>
        for MoonshotCreateTokenInput {
            fn from(value: super::MoonshotCreateTokenInput) -> Self {
                Self {
                    banner: Ok(value.banner),
                    description: Ok(value.description),
                    dex: Ok(value.dex),
                    icon: Ok(value.icon),
                    links: Ok(value.links),
                    migration_dex: Ok(value.migration_dex),
                    name: Ok(value.name),
                    priority_fee: Ok(value.priority_fee),
                    symbol: Ok(value.symbol),
                    token_amount: Ok(value.token_amount),
                    user_address: Ok(value.user_address),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct MoonshotCreateTokenReply {
            extra: ::std::result::Result<
                ::serde_json::Map<::std::string::String, ::serde_json::Value>,
                ::std::string::String,
            >,
            serialized_tx: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for MoonshotCreateTokenReply {
            fn default() -> Self {
                Self {
                    extra: Err("no value supplied for extra".to_string()),
                    serialized_tx: Err("no value supplied for serialized_tx".to_string()),
                }
            }
        }
        impl MoonshotCreateTokenReply {
            pub fn extra<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<
                    ::serde_json::Map<::std::string::String, ::serde_json::Value>,
                >,
                T::Error: ::std::fmt::Display,
            {
                self.extra = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for extra: {}", e)
                    });
                self
            }
            pub fn serialized_tx<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.serialized_tx = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for serialized_tx: {}", e
                        )
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<MoonshotCreateTokenReply>
        for super::MoonshotCreateTokenReply {
            type Error = super::error::ConversionError;
            fn try_from(
                value: MoonshotCreateTokenReply,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    extra: value.extra?,
                    serialized_tx: value.serialized_tx?,
                })
            }
        }
        impl ::std::convert::From<super::MoonshotCreateTokenReply>
        for MoonshotCreateTokenReply {
            fn from(value: super::MoonshotCreateTokenReply) -> Self {
                Self {
                    extra: Ok(value.extra),
                    serialized_tx: Ok(value.serialized_tx),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct MoonshotSubmitCreateTokenInput {
            extra: ::std::result::Result<
                ::serde_json::Map<::std::string::String, ::serde_json::Value>,
                ::std::string::String,
            >,
            signed_tx: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for MoonshotSubmitCreateTokenInput {
            fn default() -> Self {
                Self {
                    extra: Ok(Default::default()),
                    signed_tx: Err("no value supplied for signed_tx".to_string()),
                }
            }
        }
        impl MoonshotSubmitCreateTokenInput {
            pub fn extra<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<
                    ::serde_json::Map<::std::string::String, ::serde_json::Value>,
                >,
                T::Error: ::std::fmt::Display,
            {
                self.extra = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for extra: {}", e)
                    });
                self
            }
            pub fn signed_tx<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.signed_tx = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for signed_tx: {}", e)
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<MoonshotSubmitCreateTokenInput>
        for super::MoonshotSubmitCreateTokenInput {
            type Error = super::error::ConversionError;
            fn try_from(
                value: MoonshotSubmitCreateTokenInput,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    extra: value.extra?,
                    signed_tx: value.signed_tx?,
                })
            }
        }
        impl ::std::convert::From<super::MoonshotSubmitCreateTokenInput>
        for MoonshotSubmitCreateTokenInput {
            fn from(value: super::MoonshotSubmitCreateTokenInput) -> Self {
                Self {
                    extra: Ok(value.extra),
                    signed_tx: Ok(value.signed_tx),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct MoonshotSubmitCreateTokenResponse {
            signature: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            slot: ::std::result::Result<
                ::std::option::Option<f64>,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for MoonshotSubmitCreateTokenResponse {
            fn default() -> Self {
                Self {
                    signature: Ok(Default::default()),
                    slot: Ok(Default::default()),
                }
            }
        }
        impl MoonshotSubmitCreateTokenResponse {
            pub fn signature<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.signature = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for signature: {}", e)
                    });
                self
            }
            pub fn slot<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<f64>>,
                T::Error: ::std::fmt::Display,
            {
                self.slot = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for slot: {}", e)
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<MoonshotSubmitCreateTokenResponse>
        for super::MoonshotSubmitCreateTokenResponse {
            type Error = super::error::ConversionError;
            fn try_from(
                value: MoonshotSubmitCreateTokenResponse,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    signature: value.signature?,
                    slot: value.slot?,
                })
            }
        }
        impl ::std::convert::From<super::MoonshotSubmitCreateTokenResponse>
        for MoonshotSubmitCreateTokenResponse {
            fn from(value: super::MoonshotSubmitCreateTokenResponse) -> Self {
                Self {
                    signature: Ok(value.signature),
                    slot: Ok(value.slot),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct NetworkIdentificationOrg {
            name: ::std::result::Result<::std::string::String, ::std::string::String>,
        }
        impl ::std::default::Default for NetworkIdentificationOrg {
            fn default() -> Self {
                Self {
                    name: Err("no value supplied for name".to_string()),
                }
            }
        }
        impl NetworkIdentificationOrg {
            pub fn name<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.name = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for name: {}", e)
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<NetworkIdentificationOrg>
        for super::NetworkIdentificationOrg {
            type Error = super::error::ConversionError;
            fn try_from(
                value: NetworkIdentificationOrg,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self { name: value.name? })
            }
        }
        impl ::std::convert::From<super::NetworkIdentificationOrg>
        for NetworkIdentificationOrg {
            fn from(value: super::NetworkIdentificationOrg) -> Self {
                Self { name: Ok(value.name) }
            }
        }
        #[derive(Clone, Debug)]
        pub struct OnChainActivity {
            first_transaction_at: ::std::result::Result<i64, ::std::string::String>,
        }
        impl ::std::default::Default for OnChainActivity {
            fn default() -> Self {
                Self {
                    first_transaction_at: Err(
                        "no value supplied for first_transaction_at".to_string(),
                    ),
                }
            }
        }
        impl OnChainActivity {
            pub fn first_transaction_at<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<i64>,
                T::Error: ::std::fmt::Display,
            {
                self.first_transaction_at = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for first_transaction_at: {}",
                            e
                        )
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<OnChainActivity> for super::OnChainActivity {
            type Error = super::error::ConversionError;
            fn try_from(
                value: OnChainActivity,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    first_transaction_at: value.first_transaction_at?,
                })
            }
        }
        impl ::std::convert::From<super::OnChainActivity> for OnChainActivity {
            fn from(value: super::OnChainActivity) -> Self {
                Self {
                    first_transaction_at: Ok(value.first_transaction_at),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct PnlDetailItemDto {
            avg_buy_price_in_usd: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            avg_profit_per_trade_in_usd: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            avg_sell_price_in_usd: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            balance: ::std::result::Result<::std::string::String, ::std::string::String>,
            buy_amount: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            buy_amount_in_usd: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            buys: ::std::result::Result<::std::string::String, ::std::string::String>,
            current_value: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            decimals: ::std::result::Result<i64, ::std::string::String>,
            logo_uri: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            name: ::std::result::Result<::std::string::String, ::std::string::String>,
            price_in_usd: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            realized_profit_in_usd: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            realized_profit_ratio: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            sell_amount: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            sell_amount_in_usd: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            sells: ::std::result::Result<::std::string::String, ::std::string::String>,
            symbol: ::std::result::Result<::std::string::String, ::std::string::String>,
            token_address: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            total_profit_in_usd: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            total_profit_ratio: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            total_trades: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            unrealized_profit_in_usd: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            unrealized_profit_ratio: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            wallet_address: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for PnlDetailItemDto {
            fn default() -> Self {
                Self {
                    avg_buy_price_in_usd: Err(
                        "no value supplied for avg_buy_price_in_usd".to_string(),
                    ),
                    avg_profit_per_trade_in_usd: Err(
                        "no value supplied for avg_profit_per_trade_in_usd".to_string(),
                    ),
                    avg_sell_price_in_usd: Err(
                        "no value supplied for avg_sell_price_in_usd".to_string(),
                    ),
                    balance: Err("no value supplied for balance".to_string()),
                    buy_amount: Err("no value supplied for buy_amount".to_string()),
                    buy_amount_in_usd: Err(
                        "no value supplied for buy_amount_in_usd".to_string(),
                    ),
                    buys: Err("no value supplied for buys".to_string()),
                    current_value: Err(
                        "no value supplied for current_value".to_string(),
                    ),
                    decimals: Err("no value supplied for decimals".to_string()),
                    logo_uri: Ok(Default::default()),
                    name: Err("no value supplied for name".to_string()),
                    price_in_usd: Err("no value supplied for price_in_usd".to_string()),
                    realized_profit_in_usd: Err(
                        "no value supplied for realized_profit_in_usd".to_string(),
                    ),
                    realized_profit_ratio: Err(
                        "no value supplied for realized_profit_ratio".to_string(),
                    ),
                    sell_amount: Err("no value supplied for sell_amount".to_string()),
                    sell_amount_in_usd: Err(
                        "no value supplied for sell_amount_in_usd".to_string(),
                    ),
                    sells: Err("no value supplied for sells".to_string()),
                    symbol: Err("no value supplied for symbol".to_string()),
                    token_address: Err(
                        "no value supplied for token_address".to_string(),
                    ),
                    total_profit_in_usd: Err(
                        "no value supplied for total_profit_in_usd".to_string(),
                    ),
                    total_profit_ratio: Err(
                        "no value supplied for total_profit_ratio".to_string(),
                    ),
                    total_trades: Err("no value supplied for total_trades".to_string()),
                    unrealized_profit_in_usd: Err(
                        "no value supplied for unrealized_profit_in_usd".to_string(),
                    ),
                    unrealized_profit_ratio: Err(
                        "no value supplied for unrealized_profit_ratio".to_string(),
                    ),
                    wallet_address: Err(
                        "no value supplied for wallet_address".to_string(),
                    ),
                }
            }
        }
        impl PnlDetailItemDto {
            pub fn avg_buy_price_in_usd<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.avg_buy_price_in_usd = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for avg_buy_price_in_usd: {}",
                            e
                        )
                    });
                self
            }
            pub fn avg_profit_per_trade_in_usd<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.avg_profit_per_trade_in_usd = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for avg_profit_per_trade_in_usd: {}",
                            e
                        )
                    });
                self
            }
            pub fn avg_sell_price_in_usd<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.avg_sell_price_in_usd = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for avg_sell_price_in_usd: {}",
                            e
                        )
                    });
                self
            }
            pub fn balance<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.balance = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for balance: {}", e)
                    });
                self
            }
            pub fn buy_amount<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.buy_amount = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for buy_amount: {}", e)
                    });
                self
            }
            pub fn buy_amount_in_usd<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.buy_amount_in_usd = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for buy_amount_in_usd: {}",
                            e
                        )
                    });
                self
            }
            pub fn buys<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.buys = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for buys: {}", e)
                    });
                self
            }
            pub fn current_value<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.current_value = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for current_value: {}", e
                        )
                    });
                self
            }
            pub fn decimals<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<i64>,
                T::Error: ::std::fmt::Display,
            {
                self.decimals = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for decimals: {}", e)
                    });
                self
            }
            pub fn logo_uri<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.logo_uri = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for logo_uri: {}", e)
                    });
                self
            }
            pub fn name<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.name = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for name: {}", e)
                    });
                self
            }
            pub fn price_in_usd<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.price_in_usd = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for price_in_usd: {}", e
                        )
                    });
                self
            }
            pub fn realized_profit_in_usd<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.realized_profit_in_usd = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for realized_profit_in_usd: {}",
                            e
                        )
                    });
                self
            }
            pub fn realized_profit_ratio<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.realized_profit_ratio = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for realized_profit_ratio: {}",
                            e
                        )
                    });
                self
            }
            pub fn sell_amount<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.sell_amount = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for sell_amount: {}", e)
                    });
                self
            }
            pub fn sell_amount_in_usd<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.sell_amount_in_usd = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for sell_amount_in_usd: {}",
                            e
                        )
                    });
                self
            }
            pub fn sells<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.sells = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for sells: {}", e)
                    });
                self
            }
            pub fn symbol<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.symbol = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for symbol: {}", e)
                    });
                self
            }
            pub fn token_address<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.token_address = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for token_address: {}", e
                        )
                    });
                self
            }
            pub fn total_profit_in_usd<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.total_profit_in_usd = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for total_profit_in_usd: {}",
                            e
                        )
                    });
                self
            }
            pub fn total_profit_ratio<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.total_profit_ratio = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for total_profit_ratio: {}",
                            e
                        )
                    });
                self
            }
            pub fn total_trades<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.total_trades = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for total_trades: {}", e
                        )
                    });
                self
            }
            pub fn unrealized_profit_in_usd<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.unrealized_profit_in_usd = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for unrealized_profit_in_usd: {}",
                            e
                        )
                    });
                self
            }
            pub fn unrealized_profit_ratio<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.unrealized_profit_ratio = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for unrealized_profit_ratio: {}",
                            e
                        )
                    });
                self
            }
            pub fn wallet_address<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.wallet_address = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for wallet_address: {}", e
                        )
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<PnlDetailItemDto> for super::PnlDetailItemDto {
            type Error = super::error::ConversionError;
            fn try_from(
                value: PnlDetailItemDto,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    avg_buy_price_in_usd: value.avg_buy_price_in_usd?,
                    avg_profit_per_trade_in_usd: value.avg_profit_per_trade_in_usd?,
                    avg_sell_price_in_usd: value.avg_sell_price_in_usd?,
                    balance: value.balance?,
                    buy_amount: value.buy_amount?,
                    buy_amount_in_usd: value.buy_amount_in_usd?,
                    buys: value.buys?,
                    current_value: value.current_value?,
                    decimals: value.decimals?,
                    logo_uri: value.logo_uri?,
                    name: value.name?,
                    price_in_usd: value.price_in_usd?,
                    realized_profit_in_usd: value.realized_profit_in_usd?,
                    realized_profit_ratio: value.realized_profit_ratio?,
                    sell_amount: value.sell_amount?,
                    sell_amount_in_usd: value.sell_amount_in_usd?,
                    sells: value.sells?,
                    symbol: value.symbol?,
                    token_address: value.token_address?,
                    total_profit_in_usd: value.total_profit_in_usd?,
                    total_profit_ratio: value.total_profit_ratio?,
                    total_trades: value.total_trades?,
                    unrealized_profit_in_usd: value.unrealized_profit_in_usd?,
                    unrealized_profit_ratio: value.unrealized_profit_ratio?,
                    wallet_address: value.wallet_address?,
                })
            }
        }
        impl ::std::convert::From<super::PnlDetailItemDto> for PnlDetailItemDto {
            fn from(value: super::PnlDetailItemDto) -> Self {
                Self {
                    avg_buy_price_in_usd: Ok(value.avg_buy_price_in_usd),
                    avg_profit_per_trade_in_usd: Ok(value.avg_profit_per_trade_in_usd),
                    avg_sell_price_in_usd: Ok(value.avg_sell_price_in_usd),
                    balance: Ok(value.balance),
                    buy_amount: Ok(value.buy_amount),
                    buy_amount_in_usd: Ok(value.buy_amount_in_usd),
                    buys: Ok(value.buys),
                    current_value: Ok(value.current_value),
                    decimals: Ok(value.decimals),
                    logo_uri: Ok(value.logo_uri),
                    name: Ok(value.name),
                    price_in_usd: Ok(value.price_in_usd),
                    realized_profit_in_usd: Ok(value.realized_profit_in_usd),
                    realized_profit_ratio: Ok(value.realized_profit_ratio),
                    sell_amount: Ok(value.sell_amount),
                    sell_amount_in_usd: Ok(value.sell_amount_in_usd),
                    sells: Ok(value.sells),
                    symbol: Ok(value.symbol),
                    token_address: Ok(value.token_address),
                    total_profit_in_usd: Ok(value.total_profit_in_usd),
                    total_profit_ratio: Ok(value.total_profit_ratio),
                    total_trades: Ok(value.total_trades),
                    unrealized_profit_in_usd: Ok(value.unrealized_profit_in_usd),
                    unrealized_profit_ratio: Ok(value.unrealized_profit_ratio),
                    wallet_address: Ok(value.wallet_address),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct PnlDetailSummaryDto {
            avg_profit_per_trade_in_usd: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            buy_amount_in_usd: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            buys: ::std::result::Result<::std::string::String, ::std::string::String>,
            current_value: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            losses: ::std::result::Result<::std::string::String, ::std::string::String>,
            realized_profit_in_usd: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            realized_profit_ratio: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            sell_amount_in_usd: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            sells: ::std::result::Result<::std::string::String, ::std::string::String>,
            tokens: ::std::result::Result<::std::string::String, ::std::string::String>,
            total_cost_in_usd: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            total_profit_in_usd: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            total_trades: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            unrealized_profit_in_usd: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            win_rate: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            wins: ::std::result::Result<::std::string::String, ::std::string::String>,
        }
        impl ::std::default::Default for PnlDetailSummaryDto {
            fn default() -> Self {
                Self {
                    avg_profit_per_trade_in_usd: Err(
                        "no value supplied for avg_profit_per_trade_in_usd".to_string(),
                    ),
                    buy_amount_in_usd: Err(
                        "no value supplied for buy_amount_in_usd".to_string(),
                    ),
                    buys: Err("no value supplied for buys".to_string()),
                    current_value: Err(
                        "no value supplied for current_value".to_string(),
                    ),
                    losses: Err("no value supplied for losses".to_string()),
                    realized_profit_in_usd: Err(
                        "no value supplied for realized_profit_in_usd".to_string(),
                    ),
                    realized_profit_ratio: Err(
                        "no value supplied for realized_profit_ratio".to_string(),
                    ),
                    sell_amount_in_usd: Err(
                        "no value supplied for sell_amount_in_usd".to_string(),
                    ),
                    sells: Err("no value supplied for sells".to_string()),
                    tokens: Err("no value supplied for tokens".to_string()),
                    total_cost_in_usd: Err(
                        "no value supplied for total_cost_in_usd".to_string(),
                    ),
                    total_profit_in_usd: Err(
                        "no value supplied for total_profit_in_usd".to_string(),
                    ),
                    total_trades: Err("no value supplied for total_trades".to_string()),
                    unrealized_profit_in_usd: Err(
                        "no value supplied for unrealized_profit_in_usd".to_string(),
                    ),
                    win_rate: Err("no value supplied for win_rate".to_string()),
                    wins: Err("no value supplied for wins".to_string()),
                }
            }
        }
        impl PnlDetailSummaryDto {
            pub fn avg_profit_per_trade_in_usd<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.avg_profit_per_trade_in_usd = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for avg_profit_per_trade_in_usd: {}",
                            e
                        )
                    });
                self
            }
            pub fn buy_amount_in_usd<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.buy_amount_in_usd = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for buy_amount_in_usd: {}",
                            e
                        )
                    });
                self
            }
            pub fn buys<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.buys = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for buys: {}", e)
                    });
                self
            }
            pub fn current_value<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.current_value = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for current_value: {}", e
                        )
                    });
                self
            }
            pub fn losses<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.losses = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for losses: {}", e)
                    });
                self
            }
            pub fn realized_profit_in_usd<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.realized_profit_in_usd = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for realized_profit_in_usd: {}",
                            e
                        )
                    });
                self
            }
            pub fn realized_profit_ratio<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.realized_profit_ratio = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for realized_profit_ratio: {}",
                            e
                        )
                    });
                self
            }
            pub fn sell_amount_in_usd<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.sell_amount_in_usd = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for sell_amount_in_usd: {}",
                            e
                        )
                    });
                self
            }
            pub fn sells<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.sells = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for sells: {}", e)
                    });
                self
            }
            pub fn tokens<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.tokens = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for tokens: {}", e)
                    });
                self
            }
            pub fn total_cost_in_usd<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.total_cost_in_usd = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for total_cost_in_usd: {}",
                            e
                        )
                    });
                self
            }
            pub fn total_profit_in_usd<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.total_profit_in_usd = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for total_profit_in_usd: {}",
                            e
                        )
                    });
                self
            }
            pub fn total_trades<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.total_trades = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for total_trades: {}", e
                        )
                    });
                self
            }
            pub fn unrealized_profit_in_usd<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.unrealized_profit_in_usd = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for unrealized_profit_in_usd: {}",
                            e
                        )
                    });
                self
            }
            pub fn win_rate<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.win_rate = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for win_rate: {}", e)
                    });
                self
            }
            pub fn wins<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.wins = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for wins: {}", e)
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<PnlDetailSummaryDto>
        for super::PnlDetailSummaryDto {
            type Error = super::error::ConversionError;
            fn try_from(
                value: PnlDetailSummaryDto,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    avg_profit_per_trade_in_usd: value.avg_profit_per_trade_in_usd?,
                    buy_amount_in_usd: value.buy_amount_in_usd?,
                    buys: value.buys?,
                    current_value: value.current_value?,
                    losses: value.losses?,
                    realized_profit_in_usd: value.realized_profit_in_usd?,
                    realized_profit_ratio: value.realized_profit_ratio?,
                    sell_amount_in_usd: value.sell_amount_in_usd?,
                    sells: value.sells?,
                    tokens: value.tokens?,
                    total_cost_in_usd: value.total_cost_in_usd?,
                    total_profit_in_usd: value.total_profit_in_usd?,
                    total_trades: value.total_trades?,
                    unrealized_profit_in_usd: value.unrealized_profit_in_usd?,
                    win_rate: value.win_rate?,
                    wins: value.wins?,
                })
            }
        }
        impl ::std::convert::From<super::PnlDetailSummaryDto> for PnlDetailSummaryDto {
            fn from(value: super::PnlDetailSummaryDto) -> Self {
                Self {
                    avg_profit_per_trade_in_usd: Ok(value.avg_profit_per_trade_in_usd),
                    buy_amount_in_usd: Ok(value.buy_amount_in_usd),
                    buys: Ok(value.buys),
                    current_value: Ok(value.current_value),
                    losses: Ok(value.losses),
                    realized_profit_in_usd: Ok(value.realized_profit_in_usd),
                    realized_profit_ratio: Ok(value.realized_profit_ratio),
                    sell_amount_in_usd: Ok(value.sell_amount_in_usd),
                    sells: Ok(value.sells),
                    tokens: Ok(value.tokens),
                    total_cost_in_usd: Ok(value.total_cost_in_usd),
                    total_profit_in_usd: Ok(value.total_profit_in_usd),
                    total_trades: Ok(value.total_trades),
                    unrealized_profit_in_usd: Ok(value.unrealized_profit_in_usd),
                    win_rate: Ok(value.win_rate),
                    wins: Ok(value.wins),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct PnlDetailsPage {
            data: ::std::result::Result<
                ::std::vec::Vec<super::PnlDetailItemDto>,
                ::std::string::String,
            >,
            end_cursor: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            has_next: ::std::result::Result<bool, ::std::string::String>,
            has_prev: ::std::result::Result<bool, ::std::string::String>,
            start_cursor: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            summary: ::std::result::Result<
                super::PnlDetailSummaryDto,
                ::std::string::String,
            >,
            total: ::std::result::Result<i64, ::std::string::String>,
        }
        impl ::std::default::Default for PnlDetailsPage {
            fn default() -> Self {
                Self {
                    data: Err("no value supplied for data".to_string()),
                    end_cursor: Ok(Default::default()),
                    has_next: Ok(Default::default()),
                    has_prev: Ok(Default::default()),
                    start_cursor: Ok(Default::default()),
                    summary: Err("no value supplied for summary".to_string()),
                    total: Ok(Default::default()),
                }
            }
        }
        impl PnlDetailsPage {
            pub fn data<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::vec::Vec<super::PnlDetailItemDto>>,
                T::Error: ::std::fmt::Display,
            {
                self.data = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for data: {}", e)
                    });
                self
            }
            pub fn end_cursor<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.end_cursor = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for end_cursor: {}", e)
                    });
                self
            }
            pub fn has_next<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<bool>,
                T::Error: ::std::fmt::Display,
            {
                self.has_next = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for has_next: {}", e)
                    });
                self
            }
            pub fn has_prev<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<bool>,
                T::Error: ::std::fmt::Display,
            {
                self.has_prev = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for has_prev: {}", e)
                    });
                self
            }
            pub fn start_cursor<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.start_cursor = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for start_cursor: {}", e
                        )
                    });
                self
            }
            pub fn summary<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<super::PnlDetailSummaryDto>,
                T::Error: ::std::fmt::Display,
            {
                self.summary = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for summary: {}", e)
                    });
                self
            }
            pub fn total<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<i64>,
                T::Error: ::std::fmt::Display,
            {
                self.total = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for total: {}", e)
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<PnlDetailsPage> for super::PnlDetailsPage {
            type Error = super::error::ConversionError;
            fn try_from(
                value: PnlDetailsPage,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    data: value.data?,
                    end_cursor: value.end_cursor?,
                    has_next: value.has_next?,
                    has_prev: value.has_prev?,
                    start_cursor: value.start_cursor?,
                    summary: value.summary?,
                    total: value.total?,
                })
            }
        }
        impl ::std::convert::From<super::PnlDetailsPage> for PnlDetailsPage {
            fn from(value: super::PnlDetailsPage) -> Self {
                Self {
                    data: Ok(value.data),
                    end_cursor: Ok(value.end_cursor),
                    has_next: Ok(value.has_next),
                    has_prev: Ok(value.has_prev),
                    start_cursor: Ok(value.start_cursor),
                    summary: Ok(value.summary),
                    total: Ok(value.total),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct PumpCreateTokenInput {
            description: ::std::result::Result<
                super::PumpCreateTokenInputDescription,
                ::std::string::String,
            >,
            dex: ::std::result::Result<
                super::PumpCreateTokenInputDex,
                ::std::string::String,
            >,
            image: ::std::result::Result<::std::string::String, ::std::string::String>,
            migration_dex: ::std::result::Result<
                super::PumpCreateTokenInputMigrationDex,
                ::std::string::String,
            >,
            mint_address: ::std::result::Result<
                super::PumpCreateTokenInputMintAddress,
                ::std::string::String,
            >,
            name: ::std::result::Result<
                super::PumpCreateTokenInputName,
                ::std::string::String,
            >,
            priority_fee: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            symbol: ::std::result::Result<
                super::PumpCreateTokenInputSymbol,
                ::std::string::String,
            >,
            telegram: ::std::result::Result<
                ::std::option::Option<super::PumpCreateTokenInputTelegram>,
                ::std::string::String,
            >,
            twitter: ::std::result::Result<
                ::std::option::Option<super::PumpCreateTokenInputTwitter>,
                ::std::string::String,
            >,
            user_address: ::std::result::Result<
                super::PumpCreateTokenInputUserAddress,
                ::std::string::String,
            >,
            website: ::std::result::Result<
                ::std::option::Option<super::PumpCreateTokenInputWebsite>,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for PumpCreateTokenInput {
            fn default() -> Self {
                Self {
                    description: Err("no value supplied for description".to_string()),
                    dex: Err("no value supplied for dex".to_string()),
                    image: Err("no value supplied for image".to_string()),
                    migration_dex: Err(
                        "no value supplied for migration_dex".to_string(),
                    ),
                    mint_address: Err("no value supplied for mint_address".to_string()),
                    name: Err("no value supplied for name".to_string()),
                    priority_fee: Ok(Default::default()),
                    symbol: Err("no value supplied for symbol".to_string()),
                    telegram: Ok(Default::default()),
                    twitter: Ok(Default::default()),
                    user_address: Err("no value supplied for user_address".to_string()),
                    website: Ok(Default::default()),
                }
            }
        }
        impl PumpCreateTokenInput {
            pub fn description<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<super::PumpCreateTokenInputDescription>,
                T::Error: ::std::fmt::Display,
            {
                self.description = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for description: {}", e)
                    });
                self
            }
            pub fn dex<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<super::PumpCreateTokenInputDex>,
                T::Error: ::std::fmt::Display,
            {
                self.dex = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for dex: {}", e)
                    });
                self
            }
            pub fn image<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.image = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for image: {}", e)
                    });
                self
            }
            pub fn migration_dex<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<super::PumpCreateTokenInputMigrationDex>,
                T::Error: ::std::fmt::Display,
            {
                self.migration_dex = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for migration_dex: {}", e
                        )
                    });
                self
            }
            pub fn mint_address<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<super::PumpCreateTokenInputMintAddress>,
                T::Error: ::std::fmt::Display,
            {
                self.mint_address = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for mint_address: {}", e
                        )
                    });
                self
            }
            pub fn name<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<super::PumpCreateTokenInputName>,
                T::Error: ::std::fmt::Display,
            {
                self.name = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for name: {}", e)
                    });
                self
            }
            pub fn priority_fee<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.priority_fee = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for priority_fee: {}", e
                        )
                    });
                self
            }
            pub fn symbol<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<super::PumpCreateTokenInputSymbol>,
                T::Error: ::std::fmt::Display,
            {
                self.symbol = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for symbol: {}", e)
                    });
                self
            }
            pub fn telegram<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<
                    ::std::option::Option<super::PumpCreateTokenInputTelegram>,
                >,
                T::Error: ::std::fmt::Display,
            {
                self.telegram = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for telegram: {}", e)
                    });
                self
            }
            pub fn twitter<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<
                    ::std::option::Option<super::PumpCreateTokenInputTwitter>,
                >,
                T::Error: ::std::fmt::Display,
            {
                self.twitter = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for twitter: {}", e)
                    });
                self
            }
            pub fn user_address<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<super::PumpCreateTokenInputUserAddress>,
                T::Error: ::std::fmt::Display,
            {
                self.user_address = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for user_address: {}", e
                        )
                    });
                self
            }
            pub fn website<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<
                    ::std::option::Option<super::PumpCreateTokenInputWebsite>,
                >,
                T::Error: ::std::fmt::Display,
            {
                self.website = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for website: {}", e)
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<PumpCreateTokenInput>
        for super::PumpCreateTokenInput {
            type Error = super::error::ConversionError;
            fn try_from(
                value: PumpCreateTokenInput,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    description: value.description?,
                    dex: value.dex?,
                    image: value.image?,
                    migration_dex: value.migration_dex?,
                    mint_address: value.mint_address?,
                    name: value.name?,
                    priority_fee: value.priority_fee?,
                    symbol: value.symbol?,
                    telegram: value.telegram?,
                    twitter: value.twitter?,
                    user_address: value.user_address?,
                    website: value.website?,
                })
            }
        }
        impl ::std::convert::From<super::PumpCreateTokenInput> for PumpCreateTokenInput {
            fn from(value: super::PumpCreateTokenInput) -> Self {
                Self {
                    description: Ok(value.description),
                    dex: Ok(value.dex),
                    image: Ok(value.image),
                    migration_dex: Ok(value.migration_dex),
                    mint_address: Ok(value.mint_address),
                    name: Ok(value.name),
                    priority_fee: Ok(value.priority_fee),
                    symbol: Ok(value.symbol),
                    telegram: Ok(value.telegram),
                    twitter: Ok(value.twitter),
                    user_address: Ok(value.user_address),
                    website: Ok(value.website),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct PumpCreateTokenReply {
            extra: ::std::result::Result<
                ::serde_json::Map<::std::string::String, ::serde_json::Value>,
                ::std::string::String,
            >,
            serialized_tx: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for PumpCreateTokenReply {
            fn default() -> Self {
                Self {
                    extra: Ok(Default::default()),
                    serialized_tx: Err("no value supplied for serialized_tx".to_string()),
                }
            }
        }
        impl PumpCreateTokenReply {
            pub fn extra<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<
                    ::serde_json::Map<::std::string::String, ::serde_json::Value>,
                >,
                T::Error: ::std::fmt::Display,
            {
                self.extra = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for extra: {}", e)
                    });
                self
            }
            pub fn serialized_tx<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.serialized_tx = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for serialized_tx: {}", e
                        )
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<PumpCreateTokenReply>
        for super::PumpCreateTokenReply {
            type Error = super::error::ConversionError;
            fn try_from(
                value: PumpCreateTokenReply,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    extra: value.extra?,
                    serialized_tx: value.serialized_tx?,
                })
            }
        }
        impl ::std::convert::From<super::PumpCreateTokenReply> for PumpCreateTokenReply {
            fn from(value: super::PumpCreateTokenReply) -> Self {
                Self {
                    extra: Ok(value.extra),
                    serialized_tx: Ok(value.serialized_tx),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct RedPacketClaimDto {
            amount: ::std::result::Result<::std::string::String, ::std::string::String>,
            chain: ::std::result::Result<super::Chain, ::std::string::String>,
            claimed_at: ::std::result::Result<i64, ::std::string::String>,
            claimer: ::std::result::Result<::std::string::String, ::std::string::String>,
            creator: ::std::result::Result<::std::string::String, ::std::string::String>,
            mint: ::std::result::Result<::std::string::String, ::std::string::String>,
            packet_id: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            tx_hash: ::std::result::Result<::std::string::String, ::std::string::String>,
        }
        impl ::std::default::Default for RedPacketClaimDto {
            fn default() -> Self {
                Self {
                    amount: Err("no value supplied for amount".to_string()),
                    chain: Err("no value supplied for chain".to_string()),
                    claimed_at: Err("no value supplied for claimed_at".to_string()),
                    claimer: Err("no value supplied for claimer".to_string()),
                    creator: Err("no value supplied for creator".to_string()),
                    mint: Err("no value supplied for mint".to_string()),
                    packet_id: Err("no value supplied for packet_id".to_string()),
                    tx_hash: Err("no value supplied for tx_hash".to_string()),
                }
            }
        }
        impl RedPacketClaimDto {
            pub fn amount<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.amount = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for amount: {}", e)
                    });
                self
            }
            pub fn chain<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<super::Chain>,
                T::Error: ::std::fmt::Display,
            {
                self.chain = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for chain: {}", e)
                    });
                self
            }
            pub fn claimed_at<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<i64>,
                T::Error: ::std::fmt::Display,
            {
                self.claimed_at = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for claimed_at: {}", e)
                    });
                self
            }
            pub fn claimer<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.claimer = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for claimer: {}", e)
                    });
                self
            }
            pub fn creator<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.creator = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for creator: {}", e)
                    });
                self
            }
            pub fn mint<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.mint = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for mint: {}", e)
                    });
                self
            }
            pub fn packet_id<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.packet_id = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for packet_id: {}", e)
                    });
                self
            }
            pub fn tx_hash<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.tx_hash = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for tx_hash: {}", e)
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<RedPacketClaimDto> for super::RedPacketClaimDto {
            type Error = super::error::ConversionError;
            fn try_from(
                value: RedPacketClaimDto,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    amount: value.amount?,
                    chain: value.chain?,
                    claimed_at: value.claimed_at?,
                    claimer: value.claimer?,
                    creator: value.creator?,
                    mint: value.mint?,
                    packet_id: value.packet_id?,
                    tx_hash: value.tx_hash?,
                })
            }
        }
        impl ::std::convert::From<super::RedPacketClaimDto> for RedPacketClaimDto {
            fn from(value: super::RedPacketClaimDto) -> Self {
                Self {
                    amount: Ok(value.amount),
                    chain: Ok(value.chain),
                    claimed_at: Ok(value.claimed_at),
                    claimer: Ok(value.claimer),
                    creator: Ok(value.creator),
                    mint: Ok(value.mint),
                    packet_id: Ok(value.packet_id),
                    tx_hash: Ok(value.tx_hash),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct RedPacketClaimsPage {
            end_cursor: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            has_next_page: ::std::result::Result<bool, ::std::string::String>,
            records: ::std::result::Result<
                ::std::vec::Vec<super::RedPacketClaimDto>,
                ::std::string::String,
            >,
            start_cursor: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            total: ::std::result::Result<i64, ::std::string::String>,
        }
        impl ::std::default::Default for RedPacketClaimsPage {
            fn default() -> Self {
                Self {
                    end_cursor: Err("no value supplied for end_cursor".to_string()),
                    has_next_page: Err(
                        "no value supplied for has_next_page".to_string(),
                    ),
                    records: Err("no value supplied for records".to_string()),
                    start_cursor: Err("no value supplied for start_cursor".to_string()),
                    total: Err("no value supplied for total".to_string()),
                }
            }
        }
        impl RedPacketClaimsPage {
            pub fn end_cursor<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.end_cursor = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for end_cursor: {}", e)
                    });
                self
            }
            pub fn has_next_page<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<bool>,
                T::Error: ::std::fmt::Display,
            {
                self.has_next_page = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for has_next_page: {}", e
                        )
                    });
                self
            }
            pub fn records<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::vec::Vec<super::RedPacketClaimDto>>,
                T::Error: ::std::fmt::Display,
            {
                self.records = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for records: {}", e)
                    });
                self
            }
            pub fn start_cursor<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.start_cursor = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for start_cursor: {}", e
                        )
                    });
                self
            }
            pub fn total<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<i64>,
                T::Error: ::std::fmt::Display,
            {
                self.total = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for total: {}", e)
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<RedPacketClaimsPage>
        for super::RedPacketClaimsPage {
            type Error = super::error::ConversionError;
            fn try_from(
                value: RedPacketClaimsPage,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    end_cursor: value.end_cursor?,
                    has_next_page: value.has_next_page?,
                    records: value.records?,
                    start_cursor: value.start_cursor?,
                    total: value.total?,
                })
            }
        }
        impl ::std::convert::From<super::RedPacketClaimsPage> for RedPacketClaimsPage {
            fn from(value: super::RedPacketClaimsPage) -> Self {
                Self {
                    end_cursor: Ok(value.end_cursor),
                    has_next_page: Ok(value.has_next_page),
                    records: Ok(value.records),
                    start_cursor: Ok(value.start_cursor),
                    total: Ok(value.total),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct RedPacketDto {
            chain: ::std::result::Result<super::Chain, ::std::string::String>,
            claim_authority: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            claimed_amount: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            claimed_count: ::std::result::Result<i64, ::std::string::String>,
            created_at: ::std::result::Result<i64, ::std::string::String>,
            creator: ::std::result::Result<::std::string::String, ::std::string::String>,
            expiration: ::std::result::Result<i64, ::std::string::String>,
            expired: ::std::result::Result<bool, ::std::string::String>,
            expired_at: ::std::result::Result<i64, ::std::string::String>,
            id: ::std::result::Result<::std::string::String, ::std::string::String>,
            max_claims: ::std::result::Result<i64, ::std::string::String>,
            memo: ::std::result::Result<::std::string::String, ::std::string::String>,
            mint: ::std::result::Result<::std::string::String, ::std::string::String>,
            refunded_amount: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            share_id: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            total_amount: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            tx_hash: ::std::result::Result<::std::string::String, ::std::string::String>,
        }
        impl ::std::default::Default for RedPacketDto {
            fn default() -> Self {
                Self {
                    chain: Err("no value supplied for chain".to_string()),
                    claim_authority: Err(
                        "no value supplied for claim_authority".to_string(),
                    ),
                    claimed_amount: Err(
                        "no value supplied for claimed_amount".to_string(),
                    ),
                    claimed_count: Err(
                        "no value supplied for claimed_count".to_string(),
                    ),
                    created_at: Err("no value supplied for created_at".to_string()),
                    creator: Err("no value supplied for creator".to_string()),
                    expiration: Err("no value supplied for expiration".to_string()),
                    expired: Err("no value supplied for expired".to_string()),
                    expired_at: Err("no value supplied for expired_at".to_string()),
                    id: Err("no value supplied for id".to_string()),
                    max_claims: Err("no value supplied for max_claims".to_string()),
                    memo: Err("no value supplied for memo".to_string()),
                    mint: Err("no value supplied for mint".to_string()),
                    refunded_amount: Err(
                        "no value supplied for refunded_amount".to_string(),
                    ),
                    share_id: Err("no value supplied for share_id".to_string()),
                    total_amount: Err("no value supplied for total_amount".to_string()),
                    tx_hash: Err("no value supplied for tx_hash".to_string()),
                }
            }
        }
        impl RedPacketDto {
            pub fn chain<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<super::Chain>,
                T::Error: ::std::fmt::Display,
            {
                self.chain = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for chain: {}", e)
                    });
                self
            }
            pub fn claim_authority<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.claim_authority = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for claim_authority: {}", e
                        )
                    });
                self
            }
            pub fn claimed_amount<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.claimed_amount = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for claimed_amount: {}", e
                        )
                    });
                self
            }
            pub fn claimed_count<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<i64>,
                T::Error: ::std::fmt::Display,
            {
                self.claimed_count = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for claimed_count: {}", e
                        )
                    });
                self
            }
            pub fn created_at<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<i64>,
                T::Error: ::std::fmt::Display,
            {
                self.created_at = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for created_at: {}", e)
                    });
                self
            }
            pub fn creator<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.creator = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for creator: {}", e)
                    });
                self
            }
            pub fn expiration<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<i64>,
                T::Error: ::std::fmt::Display,
            {
                self.expiration = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for expiration: {}", e)
                    });
                self
            }
            pub fn expired<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<bool>,
                T::Error: ::std::fmt::Display,
            {
                self.expired = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for expired: {}", e)
                    });
                self
            }
            pub fn expired_at<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<i64>,
                T::Error: ::std::fmt::Display,
            {
                self.expired_at = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for expired_at: {}", e)
                    });
                self
            }
            pub fn id<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.id = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for id: {}", e)
                    });
                self
            }
            pub fn max_claims<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<i64>,
                T::Error: ::std::fmt::Display,
            {
                self.max_claims = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for max_claims: {}", e)
                    });
                self
            }
            pub fn memo<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.memo = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for memo: {}", e)
                    });
                self
            }
            pub fn mint<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.mint = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for mint: {}", e)
                    });
                self
            }
            pub fn refunded_amount<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.refunded_amount = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for refunded_amount: {}", e
                        )
                    });
                self
            }
            pub fn share_id<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.share_id = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for share_id: {}", e)
                    });
                self
            }
            pub fn total_amount<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.total_amount = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for total_amount: {}", e
                        )
                    });
                self
            }
            pub fn tx_hash<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.tx_hash = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for tx_hash: {}", e)
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<RedPacketDto> for super::RedPacketDto {
            type Error = super::error::ConversionError;
            fn try_from(
                value: RedPacketDto,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    chain: value.chain?,
                    claim_authority: value.claim_authority?,
                    claimed_amount: value.claimed_amount?,
                    claimed_count: value.claimed_count?,
                    created_at: value.created_at?,
                    creator: value.creator?,
                    expiration: value.expiration?,
                    expired: value.expired?,
                    expired_at: value.expired_at?,
                    id: value.id?,
                    max_claims: value.max_claims?,
                    memo: value.memo?,
                    mint: value.mint?,
                    refunded_amount: value.refunded_amount?,
                    share_id: value.share_id?,
                    total_amount: value.total_amount?,
                    tx_hash: value.tx_hash?,
                })
            }
        }
        impl ::std::convert::From<super::RedPacketDto> for RedPacketDto {
            fn from(value: super::RedPacketDto) -> Self {
                Self {
                    chain: Ok(value.chain),
                    claim_authority: Ok(value.claim_authority),
                    claimed_amount: Ok(value.claimed_amount),
                    claimed_count: Ok(value.claimed_count),
                    created_at: Ok(value.created_at),
                    creator: Ok(value.creator),
                    expiration: Ok(value.expiration),
                    expired: Ok(value.expired),
                    expired_at: Ok(value.expired_at),
                    id: Ok(value.id),
                    max_claims: Ok(value.max_claims),
                    memo: Ok(value.memo),
                    mint: Ok(value.mint),
                    refunded_amount: Ok(value.refunded_amount),
                    share_id: Ok(value.share_id),
                    total_amount: Ok(value.total_amount),
                    tx_hash: Ok(value.tx_hash),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct RedPacketReply {
            tx_serialize: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for RedPacketReply {
            fn default() -> Self {
                Self {
                    tx_serialize: Err("no value supplied for tx_serialize".to_string()),
                }
            }
        }
        impl RedPacketReply {
            pub fn tx_serialize<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.tx_serialize = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for tx_serialize: {}", e
                        )
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<RedPacketReply> for super::RedPacketReply {
            type Error = super::error::ConversionError;
            fn try_from(
                value: RedPacketReply,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    tx_serialize: value.tx_serialize?,
                })
            }
        }
        impl ::std::convert::From<super::RedPacketReply> for RedPacketReply {
            fn from(value: super::RedPacketReply) -> Self {
                Self {
                    tx_serialize: Ok(value.tx_serialize),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct RedPacketSendTxInput {
            signed_tx: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for RedPacketSendTxInput {
            fn default() -> Self {
                Self {
                    signed_tx: Err("no value supplied for signed_tx".to_string()),
                }
            }
        }
        impl RedPacketSendTxInput {
            pub fn signed_tx<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.signed_tx = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for signed_tx: {}", e)
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<RedPacketSendTxInput>
        for super::RedPacketSendTxInput {
            type Error = super::error::ConversionError;
            fn try_from(
                value: RedPacketSendTxInput,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    signed_tx: value.signed_tx?,
                })
            }
        }
        impl ::std::convert::From<super::RedPacketSendTxInput> for RedPacketSendTxInput {
            fn from(value: super::RedPacketSendTxInput) -> Self {
                Self {
                    signed_tx: Ok(value.signed_tx),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct RedPacketSendTxResponse {
            signature: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for RedPacketSendTxResponse {
            fn default() -> Self {
                Self {
                    signature: Err("no value supplied for signature".to_string()),
                }
            }
        }
        impl RedPacketSendTxResponse {
            pub fn signature<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.signature = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for signature: {}", e)
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<RedPacketSendTxResponse>
        for super::RedPacketSendTxResponse {
            type Error = super::error::ConversionError;
            fn try_from(
                value: RedPacketSendTxResponse,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    signature: value.signature?,
                })
            }
        }
        impl ::std::convert::From<super::RedPacketSendTxResponse>
        for RedPacketSendTxResponse {
            fn from(value: super::RedPacketSendTxResponse) -> Self {
                Self {
                    signature: Ok(value.signature),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct RedPacketsPage {
            end_cursor: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            has_next_page: ::std::result::Result<bool, ::std::string::String>,
            records: ::std::result::Result<
                ::std::vec::Vec<super::RedPacketDto>,
                ::std::string::String,
            >,
            start_cursor: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            total: ::std::result::Result<i64, ::std::string::String>,
        }
        impl ::std::default::Default for RedPacketsPage {
            fn default() -> Self {
                Self {
                    end_cursor: Err("no value supplied for end_cursor".to_string()),
                    has_next_page: Err(
                        "no value supplied for has_next_page".to_string(),
                    ),
                    records: Err("no value supplied for records".to_string()),
                    start_cursor: Err("no value supplied for start_cursor".to_string()),
                    total: Err("no value supplied for total".to_string()),
                }
            }
        }
        impl RedPacketsPage {
            pub fn end_cursor<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.end_cursor = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for end_cursor: {}", e)
                    });
                self
            }
            pub fn has_next_page<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<bool>,
                T::Error: ::std::fmt::Display,
            {
                self.has_next_page = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for has_next_page: {}", e
                        )
                    });
                self
            }
            pub fn records<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::vec::Vec<super::RedPacketDto>>,
                T::Error: ::std::fmt::Display,
            {
                self.records = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for records: {}", e)
                    });
                self
            }
            pub fn start_cursor<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.start_cursor = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for start_cursor: {}", e
                        )
                    });
                self
            }
            pub fn total<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<i64>,
                T::Error: ::std::fmt::Display,
            {
                self.total = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for total: {}", e)
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<RedPacketsPage> for super::RedPacketsPage {
            type Error = super::error::ConversionError;
            fn try_from(
                value: RedPacketsPage,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    end_cursor: value.end_cursor?,
                    has_next_page: value.has_next_page?,
                    records: value.records?,
                    start_cursor: value.start_cursor?,
                    total: value.total?,
                })
            }
        }
        impl ::std::convert::From<super::RedPacketsPage> for RedPacketsPage {
            fn from(value: super::RedPacketsPage) -> Self {
                Self {
                    end_cursor: Ok(value.end_cursor),
                    has_next_page: Ok(value.has_next_page),
                    records: Ok(value.records),
                    start_cursor: Ok(value.start_cursor),
                    total: Ok(value.total),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct RegisterAddressRequest {
            address: ::std::result::Result<::std::string::String, ::std::string::String>,
        }
        impl ::std::default::Default for RegisterAddressRequest {
            fn default() -> Self {
                Self {
                    address: Err("no value supplied for address".to_string()),
                }
            }
        }
        impl RegisterAddressRequest {
            pub fn address<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.address = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for address: {}", e)
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<RegisterAddressRequest>
        for super::RegisterAddressRequest {
            type Error = super::error::ConversionError;
            fn try_from(
                value: RegisterAddressRequest,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self { address: value.address? })
            }
        }
        impl ::std::convert::From<super::RegisterAddressRequest>
        for RegisterAddressRequest {
            fn from(value: super::RegisterAddressRequest) -> Self {
                Self { address: Ok(value.address) }
            }
        }
        #[derive(Clone, Debug)]
        pub struct RegisterAddressResponseDto {
            address: ::std::result::Result<::std::string::String, ::std::string::String>,
        }
        impl ::std::default::Default for RegisterAddressResponseDto {
            fn default() -> Self {
                Self {
                    address: Err("no value supplied for address".to_string()),
                }
            }
        }
        impl RegisterAddressResponseDto {
            pub fn address<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.address = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for address: {}", e)
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<RegisterAddressResponseDto>
        for super::RegisterAddressResponseDto {
            type Error = super::error::ConversionError;
            fn try_from(
                value: RegisterAddressResponseDto,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self { address: value.address? })
            }
        }
        impl ::std::convert::From<super::RegisterAddressResponseDto>
        for RegisterAddressResponseDto {
            fn from(value: super::RegisterAddressResponseDto) -> Self {
                Self { address: Ok(value.address) }
            }
        }
        #[derive(Clone, Debug)]
        pub struct SendTxInput {
            options: ::std::result::Result<
                ::serde_json::Map<::std::string::String, ::serde_json::Value>,
                ::std::string::String,
            >,
            signed_tx: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            submit_type: ::std::result::Result<
                ::std::option::Option<super::SendTxInputSubmitType>,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for SendTxInput {
            fn default() -> Self {
                Self {
                    options: Ok(Default::default()),
                    signed_tx: Err("no value supplied for signed_tx".to_string()),
                    submit_type: Ok(Default::default()),
                }
            }
        }
        impl SendTxInput {
            pub fn options<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<
                    ::serde_json::Map<::std::string::String, ::serde_json::Value>,
                >,
                T::Error: ::std::fmt::Display,
            {
                self.options = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for options: {}", e)
                    });
                self
            }
            pub fn signed_tx<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.signed_tx = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for signed_tx: {}", e)
                    });
                self
            }
            pub fn submit_type<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<
                    ::std::option::Option<super::SendTxInputSubmitType>,
                >,
                T::Error: ::std::fmt::Display,
            {
                self.submit_type = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for submit_type: {}", e)
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<SendTxInput> for super::SendTxInput {
            type Error = super::error::ConversionError;
            fn try_from(
                value: SendTxInput,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    options: value.options?,
                    signed_tx: value.signed_tx?,
                    submit_type: value.submit_type?,
                })
            }
        }
        impl ::std::convert::From<super::SendTxInput> for SendTxInput {
            fn from(value: super::SendTxInput) -> Self {
                Self {
                    options: Ok(value.options),
                    signed_tx: Ok(value.signed_tx),
                    submit_type: Ok(value.submit_type),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct SendTxResponse {
            elapsed_time: ::std::result::Result<i64, ::std::string::String>,
            job_id: ::std::result::Result<::std::string::String, ::std::string::String>,
            signature: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for SendTxResponse {
            fn default() -> Self {
                Self {
                    elapsed_time: Err("no value supplied for elapsed_time".to_string()),
                    job_id: Err("no value supplied for job_id".to_string()),
                    signature: Err("no value supplied for signature".to_string()),
                }
            }
        }
        impl SendTxResponse {
            pub fn elapsed_time<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<i64>,
                T::Error: ::std::fmt::Display,
            {
                self.elapsed_time = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for elapsed_time: {}", e
                        )
                    });
                self
            }
            pub fn job_id<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.job_id = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for job_id: {}", e)
                    });
                self
            }
            pub fn signature<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.signature = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for signature: {}", e)
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<SendTxResponse> for super::SendTxResponse {
            type Error = super::error::ConversionError;
            fn try_from(
                value: SendTxResponse,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    elapsed_time: value.elapsed_time?,
                    job_id: value.job_id?,
                    signature: value.signature?,
                })
            }
        }
        impl ::std::convert::From<super::SendTxResponse> for SendTxResponse {
            fn from(value: super::SendTxResponse) -> Self {
                Self {
                    elapsed_time: Ok(value.elapsed_time),
                    job_id: Ok(value.job_id),
                    signature: Ok(value.signature),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct SwapInput {
            amount: ::std::result::Result<::std::string::String, ::std::string::String>,
            dex: ::std::result::Result<super::SwapInputDex, ::std::string::String>,
            input_mint: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            output_mint: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            pool_address: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            priority_fee: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            slippage: ::std::result::Result<i64, ::std::string::String>,
            swap_mode: ::std::result::Result<
                super::SwapInputSwapMode,
                ::std::string::String,
            >,
            user_address: ::std::result::Result<
                super::SwapInputUserAddress,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for SwapInput {
            fn default() -> Self {
                Self {
                    amount: Err("no value supplied for amount".to_string()),
                    dex: Err("no value supplied for dex".to_string()),
                    input_mint: Ok(Default::default()),
                    output_mint: Ok(Default::default()),
                    pool_address: Ok(Default::default()),
                    priority_fee: Ok(Default::default()),
                    slippage: Err("no value supplied for slippage".to_string()),
                    swap_mode: Err("no value supplied for swap_mode".to_string()),
                    user_address: Err("no value supplied for user_address".to_string()),
                }
            }
        }
        impl SwapInput {
            pub fn amount<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.amount = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for amount: {}", e)
                    });
                self
            }
            pub fn dex<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<super::SwapInputDex>,
                T::Error: ::std::fmt::Display,
            {
                self.dex = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for dex: {}", e)
                    });
                self
            }
            pub fn input_mint<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.input_mint = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for input_mint: {}", e)
                    });
                self
            }
            pub fn output_mint<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.output_mint = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for output_mint: {}", e)
                    });
                self
            }
            pub fn pool_address<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.pool_address = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for pool_address: {}", e
                        )
                    });
                self
            }
            pub fn priority_fee<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.priority_fee = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for priority_fee: {}", e
                        )
                    });
                self
            }
            pub fn slippage<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<i64>,
                T::Error: ::std::fmt::Display,
            {
                self.slippage = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for slippage: {}", e)
                    });
                self
            }
            pub fn swap_mode<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<super::SwapInputSwapMode>,
                T::Error: ::std::fmt::Display,
            {
                self.swap_mode = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for swap_mode: {}", e)
                    });
                self
            }
            pub fn user_address<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<super::SwapInputUserAddress>,
                T::Error: ::std::fmt::Display,
            {
                self.user_address = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for user_address: {}", e
                        )
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<SwapInput> for super::SwapInput {
            type Error = super::error::ConversionError;
            fn try_from(
                value: SwapInput,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    amount: value.amount?,
                    dex: value.dex?,
                    input_mint: value.input_mint?,
                    output_mint: value.output_mint?,
                    pool_address: value.pool_address?,
                    priority_fee: value.priority_fee?,
                    slippage: value.slippage?,
                    swap_mode: value.swap_mode?,
                    user_address: value.user_address?,
                })
            }
        }
        impl ::std::convert::From<super::SwapInput> for SwapInput {
            fn from(value: super::SwapInput) -> Self {
                Self {
                    amount: Ok(value.amount),
                    dex: Ok(value.dex),
                    input_mint: Ok(value.input_mint),
                    output_mint: Ok(value.output_mint),
                    pool_address: Ok(value.pool_address),
                    priority_fee: Ok(value.priority_fee),
                    slippage: Ok(value.slippage),
                    swap_mode: Ok(value.swap_mode),
                    user_address: Ok(value.user_address),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct SwapReply {
            elapsed_time: ::std::result::Result<i64, ::std::string::String>,
            serialized_tx: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for SwapReply {
            fn default() -> Self {
                Self {
                    elapsed_time: Err("no value supplied for elapsed_time".to_string()),
                    serialized_tx: Err("no value supplied for serialized_tx".to_string()),
                }
            }
        }
        impl SwapReply {
            pub fn elapsed_time<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<i64>,
                T::Error: ::std::fmt::Display,
            {
                self.elapsed_time = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for elapsed_time: {}", e
                        )
                    });
                self
            }
            pub fn serialized_tx<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.serialized_tx = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for serialized_tx: {}", e
                        )
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<SwapReply> for super::SwapReply {
            type Error = super::error::ConversionError;
            fn try_from(
                value: SwapReply,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    elapsed_time: value.elapsed_time?,
                    serialized_tx: value.serialized_tx?,
                })
            }
        }
        impl ::std::convert::From<super::SwapReply> for SwapReply {
            fn from(value: super::SwapReply) -> Self {
                Self {
                    elapsed_time: Ok(value.elapsed_time),
                    serialized_tx: Ok(value.serialized_tx),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct SwapRouteInput {
            amount: ::std::result::Result<::std::string::String, ::std::string::String>,
            deadline: ::std::result::Result<
                ::std::option::Option<i64>,
                ::std::string::String,
            >,
            dex: ::std::result::Result<super::SwapRouteInputDex, ::std::string::String>,
            input_mint: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            is_anti_mev: ::std::result::Result<bool, ::std::string::String>,
            output_mint: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            permit: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            priority_fee: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            recipient_address: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            slippage: ::std::result::Result<i64, ::std::string::String>,
            swap_mode: ::std::result::Result<
                super::SwapRouteInputSwapMode,
                ::std::string::String,
            >,
            tip_fee: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            user_address: ::std::result::Result<
                super::SwapRouteInputUserAddress,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for SwapRouteInput {
            fn default() -> Self {
                Self {
                    amount: Err("no value supplied for amount".to_string()),
                    deadline: Ok(Default::default()),
                    dex: Err("no value supplied for dex".to_string()),
                    input_mint: Ok(Default::default()),
                    is_anti_mev: Ok(Default::default()),
                    output_mint: Ok(Default::default()),
                    permit: Ok(Default::default()),
                    priority_fee: Ok(Default::default()),
                    recipient_address: Ok(Default::default()),
                    slippage: Err("no value supplied for slippage".to_string()),
                    swap_mode: Err("no value supplied for swap_mode".to_string()),
                    tip_fee: Ok(Default::default()),
                    user_address: Err("no value supplied for user_address".to_string()),
                }
            }
        }
        impl SwapRouteInput {
            pub fn amount<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.amount = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for amount: {}", e)
                    });
                self
            }
            pub fn deadline<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<i64>>,
                T::Error: ::std::fmt::Display,
            {
                self.deadline = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for deadline: {}", e)
                    });
                self
            }
            pub fn dex<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<super::SwapRouteInputDex>,
                T::Error: ::std::fmt::Display,
            {
                self.dex = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for dex: {}", e)
                    });
                self
            }
            pub fn input_mint<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.input_mint = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for input_mint: {}", e)
                    });
                self
            }
            pub fn is_anti_mev<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<bool>,
                T::Error: ::std::fmt::Display,
            {
                self.is_anti_mev = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for is_anti_mev: {}", e)
                    });
                self
            }
            pub fn output_mint<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.output_mint = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for output_mint: {}", e)
                    });
                self
            }
            pub fn permit<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.permit = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for permit: {}", e)
                    });
                self
            }
            pub fn priority_fee<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.priority_fee = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for priority_fee: {}", e
                        )
                    });
                self
            }
            pub fn recipient_address<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.recipient_address = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for recipient_address: {}",
                            e
                        )
                    });
                self
            }
            pub fn slippage<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<i64>,
                T::Error: ::std::fmt::Display,
            {
                self.slippage = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for slippage: {}", e)
                    });
                self
            }
            pub fn swap_mode<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<super::SwapRouteInputSwapMode>,
                T::Error: ::std::fmt::Display,
            {
                self.swap_mode = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for swap_mode: {}", e)
                    });
                self
            }
            pub fn tip_fee<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.tip_fee = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for tip_fee: {}", e)
                    });
                self
            }
            pub fn user_address<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<super::SwapRouteInputUserAddress>,
                T::Error: ::std::fmt::Display,
            {
                self.user_address = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for user_address: {}", e
                        )
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<SwapRouteInput> for super::SwapRouteInput {
            type Error = super::error::ConversionError;
            fn try_from(
                value: SwapRouteInput,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    amount: value.amount?,
                    deadline: value.deadline?,
                    dex: value.dex?,
                    input_mint: value.input_mint?,
                    is_anti_mev: value.is_anti_mev?,
                    output_mint: value.output_mint?,
                    permit: value.permit?,
                    priority_fee: value.priority_fee?,
                    recipient_address: value.recipient_address?,
                    slippage: value.slippage?,
                    swap_mode: value.swap_mode?,
                    tip_fee: value.tip_fee?,
                    user_address: value.user_address?,
                })
            }
        }
        impl ::std::convert::From<super::SwapRouteInput> for SwapRouteInput {
            fn from(value: super::SwapRouteInput) -> Self {
                Self {
                    amount: Ok(value.amount),
                    deadline: Ok(value.deadline),
                    dex: Ok(value.dex),
                    input_mint: Ok(value.input_mint),
                    is_anti_mev: Ok(value.is_anti_mev),
                    output_mint: Ok(value.output_mint),
                    permit: Ok(value.permit),
                    priority_fee: Ok(value.priority_fee),
                    recipient_address: Ok(value.recipient_address),
                    slippage: Ok(value.slippage),
                    swap_mode: Ok(value.swap_mode),
                    tip_fee: Ok(value.tip_fee),
                    user_address: Ok(value.user_address),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct SwapRouteResponse {
            args: ::std::result::Result<super::SwapRouteInput, ::std::string::String>,
            elapsed_time: ::std::result::Result<i64, ::std::string::String>,
            route_info: ::std::result::Result<
                ::serde_json::Map<::std::string::String, ::serde_json::Value>,
                ::std::string::String,
            >,
            serialized_tx: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for SwapRouteResponse {
            fn default() -> Self {
                Self {
                    args: Err("no value supplied for args".to_string()),
                    elapsed_time: Err("no value supplied for elapsed_time".to_string()),
                    route_info: Err("no value supplied for route_info".to_string()),
                    serialized_tx: Err("no value supplied for serialized_tx".to_string()),
                }
            }
        }
        impl SwapRouteResponse {
            pub fn args<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<super::SwapRouteInput>,
                T::Error: ::std::fmt::Display,
            {
                self.args = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for args: {}", e)
                    });
                self
            }
            pub fn elapsed_time<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<i64>,
                T::Error: ::std::fmt::Display,
            {
                self.elapsed_time = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for elapsed_time: {}", e
                        )
                    });
                self
            }
            pub fn route_info<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<
                    ::serde_json::Map<::std::string::String, ::serde_json::Value>,
                >,
                T::Error: ::std::fmt::Display,
            {
                self.route_info = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for route_info: {}", e)
                    });
                self
            }
            pub fn serialized_tx<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.serialized_tx = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for serialized_tx: {}", e
                        )
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<SwapRouteResponse> for super::SwapRouteResponse {
            type Error = super::error::ConversionError;
            fn try_from(
                value: SwapRouteResponse,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    args: value.args?,
                    elapsed_time: value.elapsed_time?,
                    route_info: value.route_info?,
                    serialized_tx: value.serialized_tx?,
                })
            }
        }
        impl ::std::convert::From<super::SwapRouteResponse> for SwapRouteResponse {
            fn from(value: super::SwapRouteResponse) -> Self {
                Self {
                    args: Ok(value.args),
                    elapsed_time: Ok(value.elapsed_time),
                    route_info: Ok(value.route_info),
                    serialized_tx: Ok(value.serialized_tx),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct Token {
            address: ::std::result::Result<::std::string::String, ::std::string::String>,
            chain: ::std::result::Result<::std::string::String, ::std::string::String>,
            coingecko_coin_id: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            decimals: ::std::result::Result<i64, ::std::string::String>,
            description: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            dev_last_token_created_at: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            dev_total_tokens: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            extension: ::std::result::Result<
                ::serde_json::Map<::std::string::String, ::serde_json::Value>,
                ::std::string::String,
            >,
            extra: ::std::result::Result<
                ::std::option::Option<super::TokenExtraDto>,
                ::std::string::String,
            >,
            image_url: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            liquidity: ::std::result::Result<
                ::std::vec::Vec<super::DexPoolDto>,
                ::std::string::String,
            >,
            market: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            market_data: ::std::result::Result<
                super::TokenMarketData,
                ::std::string::String,
            >,
            metadata_address: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            name: ::std::result::Result<::std::string::String, ::std::string::String>,
            social_medias: ::std::result::Result<
                ::std::option::Option<super::TokenSocialMediasDto>,
                ::std::string::String,
            >,
            stats: ::std::result::Result<
                ::std::option::Option<super::TokenStat>,
                ::std::string::String,
            >,
            symbol: ::std::result::Result<::std::string::String, ::std::string::String>,
            token_created_at: ::std::result::Result<
                ::std::option::Option<i64>,
                ::std::string::String,
            >,
            token_created_block_height: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            token_created_slot: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            token_created_tx_signature: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            token_creators: ::std::result::Result<
                ::std::vec::Vec<super::TokenCreatorsDto>,
                ::std::string::String,
            >,
            uri: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for Token {
            fn default() -> Self {
                Self {
                    address: Err("no value supplied for address".to_string()),
                    chain: Err("no value supplied for chain".to_string()),
                    coingecko_coin_id: Ok(Default::default()),
                    decimals: Err("no value supplied for decimals".to_string()),
                    description: Ok(Default::default()),
                    dev_last_token_created_at: Ok(Default::default()),
                    dev_total_tokens: Ok(Default::default()),
                    extension: Ok(Default::default()),
                    extra: Ok(Default::default()),
                    image_url: Ok(Default::default()),
                    liquidity: Ok(Default::default()),
                    market: Ok(Default::default()),
                    market_data: Err("no value supplied for market_data".to_string()),
                    metadata_address: Ok(Default::default()),
                    name: Err("no value supplied for name".to_string()),
                    social_medias: Ok(Default::default()),
                    stats: Ok(Default::default()),
                    symbol: Err("no value supplied for symbol".to_string()),
                    token_created_at: Ok(Default::default()),
                    token_created_block_height: Ok(Default::default()),
                    token_created_slot: Ok(Default::default()),
                    token_created_tx_signature: Ok(Default::default()),
                    token_creators: Ok(Default::default()),
                    uri: Ok(Default::default()),
                }
            }
        }
        impl Token {
            pub fn address<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.address = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for address: {}", e)
                    });
                self
            }
            pub fn chain<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.chain = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for chain: {}", e)
                    });
                self
            }
            pub fn coingecko_coin_id<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.coingecko_coin_id = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for coingecko_coin_id: {}",
                            e
                        )
                    });
                self
            }
            pub fn decimals<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<i64>,
                T::Error: ::std::fmt::Display,
            {
                self.decimals = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for decimals: {}", e)
                    });
                self
            }
            pub fn description<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.description = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for description: {}", e)
                    });
                self
            }
            pub fn dev_last_token_created_at<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.dev_last_token_created_at = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for dev_last_token_created_at: {}",
                            e
                        )
                    });
                self
            }
            pub fn dev_total_tokens<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.dev_total_tokens = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for dev_total_tokens: {}", e
                        )
                    });
                self
            }
            pub fn extension<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<
                    ::serde_json::Map<::std::string::String, ::serde_json::Value>,
                >,
                T::Error: ::std::fmt::Display,
            {
                self.extension = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for extension: {}", e)
                    });
                self
            }
            pub fn extra<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<super::TokenExtraDto>>,
                T::Error: ::std::fmt::Display,
            {
                self.extra = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for extra: {}", e)
                    });
                self
            }
            pub fn image_url<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.image_url = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for image_url: {}", e)
                    });
                self
            }
            pub fn liquidity<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::vec::Vec<super::DexPoolDto>>,
                T::Error: ::std::fmt::Display,
            {
                self.liquidity = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for liquidity: {}", e)
                    });
                self
            }
            pub fn market<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.market = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for market: {}", e)
                    });
                self
            }
            pub fn market_data<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<super::TokenMarketData>,
                T::Error: ::std::fmt::Display,
            {
                self.market_data = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for market_data: {}", e)
                    });
                self
            }
            pub fn metadata_address<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.metadata_address = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for metadata_address: {}", e
                        )
                    });
                self
            }
            pub fn name<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.name = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for name: {}", e)
                    });
                self
            }
            pub fn social_medias<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<
                    ::std::option::Option<super::TokenSocialMediasDto>,
                >,
                T::Error: ::std::fmt::Display,
            {
                self.social_medias = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for social_medias: {}", e
                        )
                    });
                self
            }
            pub fn stats<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<super::TokenStat>>,
                T::Error: ::std::fmt::Display,
            {
                self.stats = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for stats: {}", e)
                    });
                self
            }
            pub fn symbol<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.symbol = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for symbol: {}", e)
                    });
                self
            }
            pub fn token_created_at<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<i64>>,
                T::Error: ::std::fmt::Display,
            {
                self.token_created_at = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for token_created_at: {}", e
                        )
                    });
                self
            }
            pub fn token_created_block_height<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.token_created_block_height = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for token_created_block_height: {}",
                            e
                        )
                    });
                self
            }
            pub fn token_created_slot<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.token_created_slot = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for token_created_slot: {}",
                            e
                        )
                    });
                self
            }
            pub fn token_created_tx_signature<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.token_created_tx_signature = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for token_created_tx_signature: {}",
                            e
                        )
                    });
                self
            }
            pub fn token_creators<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::vec::Vec<super::TokenCreatorsDto>>,
                T::Error: ::std::fmt::Display,
            {
                self.token_creators = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for token_creators: {}", e
                        )
                    });
                self
            }
            pub fn uri<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.uri = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for uri: {}", e)
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<Token> for super::Token {
            type Error = super::error::ConversionError;
            fn try_from(
                value: Token,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    address: value.address?,
                    chain: value.chain?,
                    coingecko_coin_id: value.coingecko_coin_id?,
                    decimals: value.decimals?,
                    description: value.description?,
                    dev_last_token_created_at: value.dev_last_token_created_at?,
                    dev_total_tokens: value.dev_total_tokens?,
                    extension: value.extension?,
                    extra: value.extra?,
                    image_url: value.image_url?,
                    liquidity: value.liquidity?,
                    market: value.market?,
                    market_data: value.market_data?,
                    metadata_address: value.metadata_address?,
                    name: value.name?,
                    social_medias: value.social_medias?,
                    stats: value.stats?,
                    symbol: value.symbol?,
                    token_created_at: value.token_created_at?,
                    token_created_block_height: value.token_created_block_height?,
                    token_created_slot: value.token_created_slot?,
                    token_created_tx_signature: value.token_created_tx_signature?,
                    token_creators: value.token_creators?,
                    uri: value.uri?,
                })
            }
        }
        impl ::std::convert::From<super::Token> for Token {
            fn from(value: super::Token) -> Self {
                Self {
                    address: Ok(value.address),
                    chain: Ok(value.chain),
                    coingecko_coin_id: Ok(value.coingecko_coin_id),
                    decimals: Ok(value.decimals),
                    description: Ok(value.description),
                    dev_last_token_created_at: Ok(value.dev_last_token_created_at),
                    dev_total_tokens: Ok(value.dev_total_tokens),
                    extension: Ok(value.extension),
                    extra: Ok(value.extra),
                    image_url: Ok(value.image_url),
                    liquidity: Ok(value.liquidity),
                    market: Ok(value.market),
                    market_data: Ok(value.market_data),
                    metadata_address: Ok(value.metadata_address),
                    name: Ok(value.name),
                    social_medias: Ok(value.social_medias),
                    stats: Ok(value.stats),
                    symbol: Ok(value.symbol),
                    token_created_at: Ok(value.token_created_at),
                    token_created_block_height: Ok(value.token_created_block_height),
                    token_created_slot: Ok(value.token_created_slot),
                    token_created_tx_signature: Ok(value.token_created_tx_signature),
                    token_creators: Ok(value.token_creators),
                    uri: Ok(value.uri),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct TokenCreationDto {
            block_hash: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            block_height: ::std::result::Result<i64, ::std::string::String>,
            block_slot: ::std::result::Result<i64, ::std::string::String>,
            block_timestamp: ::std::result::Result<
                ::std::option::Option<i64>,
                ::std::string::String,
            >,
            token_address: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            transaction_signature: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            type_: ::std::result::Result<
                super::TokenCreationDtoType,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for TokenCreationDto {
            fn default() -> Self {
                Self {
                    block_hash: Err("no value supplied for block_hash".to_string()),
                    block_height: Err("no value supplied for block_height".to_string()),
                    block_slot: Err("no value supplied for block_slot".to_string()),
                    block_timestamp: Ok(Default::default()),
                    token_address: Err(
                        "no value supplied for token_address".to_string(),
                    ),
                    transaction_signature: Err(
                        "no value supplied for transaction_signature".to_string(),
                    ),
                    type_: Err("no value supplied for type_".to_string()),
                }
            }
        }
        impl TokenCreationDto {
            pub fn block_hash<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.block_hash = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for block_hash: {}", e)
                    });
                self
            }
            pub fn block_height<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<i64>,
                T::Error: ::std::fmt::Display,
            {
                self.block_height = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for block_height: {}", e
                        )
                    });
                self
            }
            pub fn block_slot<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<i64>,
                T::Error: ::std::fmt::Display,
            {
                self.block_slot = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for block_slot: {}", e)
                    });
                self
            }
            pub fn block_timestamp<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<i64>>,
                T::Error: ::std::fmt::Display,
            {
                self.block_timestamp = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for block_timestamp: {}", e
                        )
                    });
                self
            }
            pub fn token_address<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.token_address = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for token_address: {}", e
                        )
                    });
                self
            }
            pub fn transaction_signature<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.transaction_signature = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for transaction_signature: {}",
                            e
                        )
                    });
                self
            }
            pub fn type_<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<super::TokenCreationDtoType>,
                T::Error: ::std::fmt::Display,
            {
                self.type_ = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for type_: {}", e)
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<TokenCreationDto> for super::TokenCreationDto {
            type Error = super::error::ConversionError;
            fn try_from(
                value: TokenCreationDto,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    block_hash: value.block_hash?,
                    block_height: value.block_height?,
                    block_slot: value.block_slot?,
                    block_timestamp: value.block_timestamp?,
                    token_address: value.token_address?,
                    transaction_signature: value.transaction_signature?,
                    type_: value.type_?,
                })
            }
        }
        impl ::std::convert::From<super::TokenCreationDto> for TokenCreationDto {
            fn from(value: super::TokenCreationDto) -> Self {
                Self {
                    block_hash: Ok(value.block_hash),
                    block_height: Ok(value.block_height),
                    block_slot: Ok(value.block_slot),
                    block_timestamp: Ok(value.block_timestamp),
                    token_address: Ok(value.token_address),
                    transaction_signature: Ok(value.transaction_signature),
                    type_: Ok(value.type_),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct TokenCreationPage {
            data: ::std::result::Result<
                ::std::vec::Vec<super::TokenCreationDto>,
                ::std::string::String,
            >,
            end_cursor: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            has_next: ::std::result::Result<bool, ::std::string::String>,
            has_prev: ::std::result::Result<bool, ::std::string::String>,
            start_cursor: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            total: ::std::result::Result<i64, ::std::string::String>,
        }
        impl ::std::default::Default for TokenCreationPage {
            fn default() -> Self {
                Self {
                    data: Err("no value supplied for data".to_string()),
                    end_cursor: Ok(Default::default()),
                    has_next: Ok(Default::default()),
                    has_prev: Ok(Default::default()),
                    start_cursor: Ok(Default::default()),
                    total: Ok(Default::default()),
                }
            }
        }
        impl TokenCreationPage {
            pub fn data<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::vec::Vec<super::TokenCreationDto>>,
                T::Error: ::std::fmt::Display,
            {
                self.data = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for data: {}", e)
                    });
                self
            }
            pub fn end_cursor<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.end_cursor = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for end_cursor: {}", e)
                    });
                self
            }
            pub fn has_next<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<bool>,
                T::Error: ::std::fmt::Display,
            {
                self.has_next = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for has_next: {}", e)
                    });
                self
            }
            pub fn has_prev<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<bool>,
                T::Error: ::std::fmt::Display,
            {
                self.has_prev = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for has_prev: {}", e)
                    });
                self
            }
            pub fn start_cursor<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.start_cursor = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for start_cursor: {}", e
                        )
                    });
                self
            }
            pub fn total<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<i64>,
                T::Error: ::std::fmt::Display,
            {
                self.total = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for total: {}", e)
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<TokenCreationPage> for super::TokenCreationPage {
            type Error = super::error::ConversionError;
            fn try_from(
                value: TokenCreationPage,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    data: value.data?,
                    end_cursor: value.end_cursor?,
                    has_next: value.has_next?,
                    has_prev: value.has_prev?,
                    start_cursor: value.start_cursor?,
                    total: value.total?,
                })
            }
        }
        impl ::std::convert::From<super::TokenCreationPage> for TokenCreationPage {
            fn from(value: super::TokenCreationPage) -> Self {
                Self {
                    data: Ok(value.data),
                    end_cursor: Ok(value.end_cursor),
                    has_next: Ok(value.has_next),
                    has_prev: Ok(value.has_prev),
                    start_cursor: Ok(value.start_cursor),
                    total: Ok(value.total),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct TokenCreatorsDto {
            address: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            is_verified: ::std::result::Result<
                ::std::option::Option<bool>,
                ::std::string::String,
            >,
            share: ::std::result::Result<
                ::std::option::Option<i64>,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for TokenCreatorsDto {
            fn default() -> Self {
                Self {
                    address: Ok(Default::default()),
                    is_verified: Ok(Default::default()),
                    share: Ok(Default::default()),
                }
            }
        }
        impl TokenCreatorsDto {
            pub fn address<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.address = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for address: {}", e)
                    });
                self
            }
            pub fn is_verified<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<bool>>,
                T::Error: ::std::fmt::Display,
            {
                self.is_verified = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for is_verified: {}", e)
                    });
                self
            }
            pub fn share<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<i64>>,
                T::Error: ::std::fmt::Display,
            {
                self.share = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for share: {}", e)
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<TokenCreatorsDto> for super::TokenCreatorsDto {
            type Error = super::error::ConversionError;
            fn try_from(
                value: TokenCreatorsDto,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    address: value.address?,
                    is_verified: value.is_verified?,
                    share: value.share?,
                })
            }
        }
        impl ::std::convert::From<super::TokenCreatorsDto> for TokenCreatorsDto {
            fn from(value: super::TokenCreatorsDto) -> Self {
                Self {
                    address: Ok(value.address),
                    is_verified: Ok(value.is_verified),
                    share: Ok(value.share),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct TokenExtraDto {
            collection_address: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            edition_nonce: ::std::result::Result<
                ::std::option::Option<i64>,
                ::std::string::String,
            >,
            freeze_authority: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            fungible: ::std::result::Result<
                ::std::option::Option<bool>,
                ::std::string::String,
            >,
            is_mutable: ::std::result::Result<
                ::std::option::Option<bool>,
                ::std::string::String,
            >,
            is_native: ::std::result::Result<
                ::std::option::Option<bool>,
                ::std::string::String,
            >,
            is_verified_collection: ::std::result::Result<
                ::std::option::Option<bool>,
                ::std::string::String,
            >,
            is_wrapped: ::std::result::Result<
                ::std::option::Option<bool>,
                ::std::string::String,
            >,
            key: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            launch_from_program_address: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            launch_from_protocol_family: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            migrated_at: ::std::result::Result<
                ::std::option::Option<i64>,
                ::std::string::String,
            >,
            migrated_to_pool_address: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            migrated_to_program_address: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            migrated_to_protocol_family: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            mint_authority: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            primary_sale_happened: ::std::result::Result<
                ::std::option::Option<bool>,
                ::std::string::String,
            >,
            program_address: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            seller_fee_basis_points: ::std::result::Result<
                ::std::option::Option<i64>,
                ::std::string::String,
            >,
            token_standard: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            update_authority: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for TokenExtraDto {
            fn default() -> Self {
                Self {
                    collection_address: Ok(Default::default()),
                    edition_nonce: Ok(Default::default()),
                    freeze_authority: Ok(Default::default()),
                    fungible: Ok(Default::default()),
                    is_mutable: Ok(Default::default()),
                    is_native: Ok(Default::default()),
                    is_verified_collection: Ok(Default::default()),
                    is_wrapped: Ok(Default::default()),
                    key: Ok(Default::default()),
                    launch_from_program_address: Ok(Default::default()),
                    launch_from_protocol_family: Ok(Default::default()),
                    migrated_at: Ok(Default::default()),
                    migrated_to_pool_address: Ok(Default::default()),
                    migrated_to_program_address: Ok(Default::default()),
                    migrated_to_protocol_family: Ok(Default::default()),
                    mint_authority: Ok(Default::default()),
                    primary_sale_happened: Ok(Default::default()),
                    program_address: Ok(Default::default()),
                    seller_fee_basis_points: Ok(Default::default()),
                    token_standard: Ok(Default::default()),
                    update_authority: Ok(Default::default()),
                }
            }
        }
        impl TokenExtraDto {
            pub fn collection_address<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.collection_address = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for collection_address: {}",
                            e
                        )
                    });
                self
            }
            pub fn edition_nonce<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<i64>>,
                T::Error: ::std::fmt::Display,
            {
                self.edition_nonce = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for edition_nonce: {}", e
                        )
                    });
                self
            }
            pub fn freeze_authority<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.freeze_authority = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for freeze_authority: {}", e
                        )
                    });
                self
            }
            pub fn fungible<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<bool>>,
                T::Error: ::std::fmt::Display,
            {
                self.fungible = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for fungible: {}", e)
                    });
                self
            }
            pub fn is_mutable<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<bool>>,
                T::Error: ::std::fmt::Display,
            {
                self.is_mutable = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for is_mutable: {}", e)
                    });
                self
            }
            pub fn is_native<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<bool>>,
                T::Error: ::std::fmt::Display,
            {
                self.is_native = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for is_native: {}", e)
                    });
                self
            }
            pub fn is_verified_collection<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<bool>>,
                T::Error: ::std::fmt::Display,
            {
                self.is_verified_collection = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for is_verified_collection: {}",
                            e
                        )
                    });
                self
            }
            pub fn is_wrapped<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<bool>>,
                T::Error: ::std::fmt::Display,
            {
                self.is_wrapped = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for is_wrapped: {}", e)
                    });
                self
            }
            pub fn key<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.key = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for key: {}", e)
                    });
                self
            }
            pub fn launch_from_program_address<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.launch_from_program_address = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for launch_from_program_address: {}",
                            e
                        )
                    });
                self
            }
            pub fn launch_from_protocol_family<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.launch_from_protocol_family = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for launch_from_protocol_family: {}",
                            e
                        )
                    });
                self
            }
            pub fn migrated_at<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<i64>>,
                T::Error: ::std::fmt::Display,
            {
                self.migrated_at = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for migrated_at: {}", e)
                    });
                self
            }
            pub fn migrated_to_pool_address<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.migrated_to_pool_address = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for migrated_to_pool_address: {}",
                            e
                        )
                    });
                self
            }
            pub fn migrated_to_program_address<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.migrated_to_program_address = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for migrated_to_program_address: {}",
                            e
                        )
                    });
                self
            }
            pub fn migrated_to_protocol_family<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.migrated_to_protocol_family = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for migrated_to_protocol_family: {}",
                            e
                        )
                    });
                self
            }
            pub fn mint_authority<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.mint_authority = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for mint_authority: {}", e
                        )
                    });
                self
            }
            pub fn primary_sale_happened<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<bool>>,
                T::Error: ::std::fmt::Display,
            {
                self.primary_sale_happened = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for primary_sale_happened: {}",
                            e
                        )
                    });
                self
            }
            pub fn program_address<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.program_address = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for program_address: {}", e
                        )
                    });
                self
            }
            pub fn seller_fee_basis_points<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<i64>>,
                T::Error: ::std::fmt::Display,
            {
                self.seller_fee_basis_points = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for seller_fee_basis_points: {}",
                            e
                        )
                    });
                self
            }
            pub fn token_standard<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.token_standard = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for token_standard: {}", e
                        )
                    });
                self
            }
            pub fn update_authority<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.update_authority = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for update_authority: {}", e
                        )
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<TokenExtraDto> for super::TokenExtraDto {
            type Error = super::error::ConversionError;
            fn try_from(
                value: TokenExtraDto,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    collection_address: value.collection_address?,
                    edition_nonce: value.edition_nonce?,
                    freeze_authority: value.freeze_authority?,
                    fungible: value.fungible?,
                    is_mutable: value.is_mutable?,
                    is_native: value.is_native?,
                    is_verified_collection: value.is_verified_collection?,
                    is_wrapped: value.is_wrapped?,
                    key: value.key?,
                    launch_from_program_address: value.launch_from_program_address?,
                    launch_from_protocol_family: value.launch_from_protocol_family?,
                    migrated_at: value.migrated_at?,
                    migrated_to_pool_address: value.migrated_to_pool_address?,
                    migrated_to_program_address: value.migrated_to_program_address?,
                    migrated_to_protocol_family: value.migrated_to_protocol_family?,
                    mint_authority: value.mint_authority?,
                    primary_sale_happened: value.primary_sale_happened?,
                    program_address: value.program_address?,
                    seller_fee_basis_points: value.seller_fee_basis_points?,
                    token_standard: value.token_standard?,
                    update_authority: value.update_authority?,
                })
            }
        }
        impl ::std::convert::From<super::TokenExtraDto> for TokenExtraDto {
            fn from(value: super::TokenExtraDto) -> Self {
                Self {
                    collection_address: Ok(value.collection_address),
                    edition_nonce: Ok(value.edition_nonce),
                    freeze_authority: Ok(value.freeze_authority),
                    fungible: Ok(value.fungible),
                    is_mutable: Ok(value.is_mutable),
                    is_native: Ok(value.is_native),
                    is_verified_collection: Ok(value.is_verified_collection),
                    is_wrapped: Ok(value.is_wrapped),
                    key: Ok(value.key),
                    launch_from_program_address: Ok(value.launch_from_program_address),
                    launch_from_protocol_family: Ok(value.launch_from_protocol_family),
                    migrated_at: Ok(value.migrated_at),
                    migrated_to_pool_address: Ok(value.migrated_to_pool_address),
                    migrated_to_program_address: Ok(value.migrated_to_program_address),
                    migrated_to_protocol_family: Ok(value.migrated_to_protocol_family),
                    mint_authority: Ok(value.mint_authority),
                    primary_sale_happened: Ok(value.primary_sale_happened),
                    program_address: Ok(value.program_address),
                    seller_fee_basis_points: Ok(value.seller_fee_basis_points),
                    token_standard: Ok(value.token_standard),
                    update_authority: Ok(value.update_authority),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct TokenHolder {
            amount: ::std::result::Result<::std::string::String, ::std::string::String>,
            amount_in_usd: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            percentage: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            wallet_address: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for TokenHolder {
            fn default() -> Self {
                Self {
                    amount: Err("no value supplied for amount".to_string()),
                    amount_in_usd: Err(
                        "no value supplied for amount_in_usd".to_string(),
                    ),
                    percentage: Err("no value supplied for percentage".to_string()),
                    wallet_address: Err(
                        "no value supplied for wallet_address".to_string(),
                    ),
                }
            }
        }
        impl TokenHolder {
            pub fn amount<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.amount = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for amount: {}", e)
                    });
                self
            }
            pub fn amount_in_usd<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.amount_in_usd = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for amount_in_usd: {}", e
                        )
                    });
                self
            }
            pub fn percentage<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.percentage = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for percentage: {}", e)
                    });
                self
            }
            pub fn wallet_address<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.wallet_address = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for wallet_address: {}", e
                        )
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<TokenHolder> for super::TokenHolder {
            type Error = super::error::ConversionError;
            fn try_from(
                value: TokenHolder,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    amount: value.amount?,
                    amount_in_usd: value.amount_in_usd?,
                    percentage: value.percentage?,
                    wallet_address: value.wallet_address?,
                })
            }
        }
        impl ::std::convert::From<super::TokenHolder> for TokenHolder {
            fn from(value: super::TokenHolder) -> Self {
                Self {
                    amount: Ok(value.amount),
                    amount_in_usd: Ok(value.amount_in_usd),
                    percentage: Ok(value.percentage),
                    wallet_address: Ok(value.wallet_address),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct TokenHolderPage {
            data: ::std::result::Result<
                ::std::vec::Vec<super::TokenHolder>,
                ::std::string::String,
            >,
            end_cursor: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            has_next: ::std::result::Result<bool, ::std::string::String>,
            has_prev: ::std::result::Result<bool, ::std::string::String>,
            start_cursor: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            total: ::std::result::Result<i64, ::std::string::String>,
        }
        impl ::std::default::Default for TokenHolderPage {
            fn default() -> Self {
                Self {
                    data: Err("no value supplied for data".to_string()),
                    end_cursor: Ok(Default::default()),
                    has_next: Ok(Default::default()),
                    has_prev: Ok(Default::default()),
                    start_cursor: Ok(Default::default()),
                    total: Ok(Default::default()),
                }
            }
        }
        impl TokenHolderPage {
            pub fn data<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::vec::Vec<super::TokenHolder>>,
                T::Error: ::std::fmt::Display,
            {
                self.data = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for data: {}", e)
                    });
                self
            }
            pub fn end_cursor<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.end_cursor = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for end_cursor: {}", e)
                    });
                self
            }
            pub fn has_next<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<bool>,
                T::Error: ::std::fmt::Display,
            {
                self.has_next = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for has_next: {}", e)
                    });
                self
            }
            pub fn has_prev<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<bool>,
                T::Error: ::std::fmt::Display,
            {
                self.has_prev = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for has_prev: {}", e)
                    });
                self
            }
            pub fn start_cursor<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.start_cursor = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for start_cursor: {}", e
                        )
                    });
                self
            }
            pub fn total<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<i64>,
                T::Error: ::std::fmt::Display,
            {
                self.total = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for total: {}", e)
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<TokenHolderPage> for super::TokenHolderPage {
            type Error = super::error::ConversionError;
            fn try_from(
                value: TokenHolderPage,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    data: value.data?,
                    end_cursor: value.end_cursor?,
                    has_next: value.has_next?,
                    has_prev: value.has_prev?,
                    start_cursor: value.start_cursor?,
                    total: value.total?,
                })
            }
        }
        impl ::std::convert::From<super::TokenHolderPage> for TokenHolderPage {
            fn from(value: super::TokenHolderPage) -> Self {
                Self {
                    data: Ok(value.data),
                    end_cursor: Ok(value.end_cursor),
                    has_next: Ok(value.has_next),
                    has_prev: Ok(value.has_prev),
                    start_cursor: Ok(value.start_cursor),
                    total: Ok(value.total),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct TokenLiquiditySnapshotDto {
            calculated_at: ::std::result::Result<i64, ::std::string::String>,
            max_liquidity_in_native: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            max_liquidity_in_usd: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            max_liquidity_pool_address: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            pool_count: ::std::result::Result<i64, ::std::string::String>,
            price_native: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            price_usd: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            snapshot_time: ::std::result::Result<i64, ::std::string::String>,
            total_liquidity_in_native: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            total_liquidity_in_usd: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for TokenLiquiditySnapshotDto {
            fn default() -> Self {
                Self {
                    calculated_at: Err(
                        "no value supplied for calculated_at".to_string(),
                    ),
                    max_liquidity_in_native: Err(
                        "no value supplied for max_liquidity_in_native".to_string(),
                    ),
                    max_liquidity_in_usd: Err(
                        "no value supplied for max_liquidity_in_usd".to_string(),
                    ),
                    max_liquidity_pool_address: Err(
                        "no value supplied for max_liquidity_pool_address".to_string(),
                    ),
                    pool_count: Err("no value supplied for pool_count".to_string()),
                    price_native: Err("no value supplied for price_native".to_string()),
                    price_usd: Err("no value supplied for price_usd".to_string()),
                    snapshot_time: Err(
                        "no value supplied for snapshot_time".to_string(),
                    ),
                    total_liquidity_in_native: Err(
                        "no value supplied for total_liquidity_in_native".to_string(),
                    ),
                    total_liquidity_in_usd: Err(
                        "no value supplied for total_liquidity_in_usd".to_string(),
                    ),
                }
            }
        }
        impl TokenLiquiditySnapshotDto {
            pub fn calculated_at<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<i64>,
                T::Error: ::std::fmt::Display,
            {
                self.calculated_at = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for calculated_at: {}", e
                        )
                    });
                self
            }
            pub fn max_liquidity_in_native<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.max_liquidity_in_native = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for max_liquidity_in_native: {}",
                            e
                        )
                    });
                self
            }
            pub fn max_liquidity_in_usd<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.max_liquidity_in_usd = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for max_liquidity_in_usd: {}",
                            e
                        )
                    });
                self
            }
            pub fn max_liquidity_pool_address<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.max_liquidity_pool_address = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for max_liquidity_pool_address: {}",
                            e
                        )
                    });
                self
            }
            pub fn pool_count<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<i64>,
                T::Error: ::std::fmt::Display,
            {
                self.pool_count = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for pool_count: {}", e)
                    });
                self
            }
            pub fn price_native<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.price_native = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for price_native: {}", e
                        )
                    });
                self
            }
            pub fn price_usd<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.price_usd = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for price_usd: {}", e)
                    });
                self
            }
            pub fn snapshot_time<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<i64>,
                T::Error: ::std::fmt::Display,
            {
                self.snapshot_time = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for snapshot_time: {}", e
                        )
                    });
                self
            }
            pub fn total_liquidity_in_native<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.total_liquidity_in_native = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for total_liquidity_in_native: {}",
                            e
                        )
                    });
                self
            }
            pub fn total_liquidity_in_usd<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.total_liquidity_in_usd = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for total_liquidity_in_usd: {}",
                            e
                        )
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<TokenLiquiditySnapshotDto>
        for super::TokenLiquiditySnapshotDto {
            type Error = super::error::ConversionError;
            fn try_from(
                value: TokenLiquiditySnapshotDto,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    calculated_at: value.calculated_at?,
                    max_liquidity_in_native: value.max_liquidity_in_native?,
                    max_liquidity_in_usd: value.max_liquidity_in_usd?,
                    max_liquidity_pool_address: value.max_liquidity_pool_address?,
                    pool_count: value.pool_count?,
                    price_native: value.price_native?,
                    price_usd: value.price_usd?,
                    snapshot_time: value.snapshot_time?,
                    total_liquidity_in_native: value.total_liquidity_in_native?,
                    total_liquidity_in_usd: value.total_liquidity_in_usd?,
                })
            }
        }
        impl ::std::convert::From<super::TokenLiquiditySnapshotDto>
        for TokenLiquiditySnapshotDto {
            fn from(value: super::TokenLiquiditySnapshotDto) -> Self {
                Self {
                    calculated_at: Ok(value.calculated_at),
                    max_liquidity_in_native: Ok(value.max_liquidity_in_native),
                    max_liquidity_in_usd: Ok(value.max_liquidity_in_usd),
                    max_liquidity_pool_address: Ok(value.max_liquidity_pool_address),
                    pool_count: Ok(value.pool_count),
                    price_native: Ok(value.price_native),
                    price_usd: Ok(value.price_usd),
                    snapshot_time: Ok(value.snapshot_time),
                    total_liquidity_in_native: Ok(value.total_liquidity_in_native),
                    total_liquidity_in_usd: Ok(value.total_liquidity_in_usd),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct TokenLiquiditySnapshotPage {
            data: ::std::result::Result<
                ::std::vec::Vec<super::TokenLiquiditySnapshotDto>,
                ::std::string::String,
            >,
            end_cursor: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            has_next: ::std::result::Result<bool, ::std::string::String>,
            has_prev: ::std::result::Result<bool, ::std::string::String>,
            start_cursor: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for TokenLiquiditySnapshotPage {
            fn default() -> Self {
                Self {
                    data: Err("no value supplied for data".to_string()),
                    end_cursor: Ok(Default::default()),
                    has_next: Err("no value supplied for has_next".to_string()),
                    has_prev: Err("no value supplied for has_prev".to_string()),
                    start_cursor: Ok(Default::default()),
                }
            }
        }
        impl TokenLiquiditySnapshotPage {
            pub fn data<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<
                    ::std::vec::Vec<super::TokenLiquiditySnapshotDto>,
                >,
                T::Error: ::std::fmt::Display,
            {
                self.data = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for data: {}", e)
                    });
                self
            }
            pub fn end_cursor<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.end_cursor = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for end_cursor: {}", e)
                    });
                self
            }
            pub fn has_next<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<bool>,
                T::Error: ::std::fmt::Display,
            {
                self.has_next = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for has_next: {}", e)
                    });
                self
            }
            pub fn has_prev<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<bool>,
                T::Error: ::std::fmt::Display,
            {
                self.has_prev = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for has_prev: {}", e)
                    });
                self
            }
            pub fn start_cursor<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.start_cursor = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for start_cursor: {}", e
                        )
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<TokenLiquiditySnapshotPage>
        for super::TokenLiquiditySnapshotPage {
            type Error = super::error::ConversionError;
            fn try_from(
                value: TokenLiquiditySnapshotPage,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    data: value.data?,
                    end_cursor: value.end_cursor?,
                    has_next: value.has_next?,
                    has_prev: value.has_prev?,
                    start_cursor: value.start_cursor?,
                })
            }
        }
        impl ::std::convert::From<super::TokenLiquiditySnapshotPage>
        for TokenLiquiditySnapshotPage {
            fn from(value: super::TokenLiquiditySnapshotPage) -> Self {
                Self {
                    data: Ok(value.data),
                    end_cursor: Ok(value.end_cursor),
                    has_next: Ok(value.has_next),
                    has_prev: Ok(value.has_prev),
                    start_cursor: Ok(value.start_cursor),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct TokenListPage {
            data: ::std::result::Result<
                ::std::vec::Vec<super::Token>,
                ::std::string::String,
            >,
            end_cursor: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            has_next: ::std::result::Result<bool, ::std::string::String>,
            has_prev: ::std::result::Result<bool, ::std::string::String>,
            start_cursor: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            total: ::std::result::Result<i64, ::std::string::String>,
        }
        impl ::std::default::Default for TokenListPage {
            fn default() -> Self {
                Self {
                    data: Err("no value supplied for data".to_string()),
                    end_cursor: Ok(Default::default()),
                    has_next: Ok(Default::default()),
                    has_prev: Ok(Default::default()),
                    start_cursor: Ok(Default::default()),
                    total: Ok(Default::default()),
                }
            }
        }
        impl TokenListPage {
            pub fn data<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::vec::Vec<super::Token>>,
                T::Error: ::std::fmt::Display,
            {
                self.data = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for data: {}", e)
                    });
                self
            }
            pub fn end_cursor<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.end_cursor = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for end_cursor: {}", e)
                    });
                self
            }
            pub fn has_next<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<bool>,
                T::Error: ::std::fmt::Display,
            {
                self.has_next = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for has_next: {}", e)
                    });
                self
            }
            pub fn has_prev<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<bool>,
                T::Error: ::std::fmt::Display,
            {
                self.has_prev = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for has_prev: {}", e)
                    });
                self
            }
            pub fn start_cursor<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.start_cursor = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for start_cursor: {}", e
                        )
                    });
                self
            }
            pub fn total<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<i64>,
                T::Error: ::std::fmt::Display,
            {
                self.total = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for total: {}", e)
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<TokenListPage> for super::TokenListPage {
            type Error = super::error::ConversionError;
            fn try_from(
                value: TokenListPage,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    data: value.data?,
                    end_cursor: value.end_cursor?,
                    has_next: value.has_next?,
                    has_prev: value.has_prev?,
                    start_cursor: value.start_cursor?,
                    total: value.total?,
                })
            }
        }
        impl ::std::convert::From<super::TokenListPage> for TokenListPage {
            fn from(value: super::TokenListPage) -> Self {
                Self {
                    data: Ok(value.data),
                    end_cursor: Ok(value.end_cursor),
                    has_next: Ok(value.has_next),
                    has_prev: Ok(value.has_prev),
                    start_cursor: Ok(value.start_cursor),
                    total: Ok(value.total),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct TokenMarketData {
            bluechip_holdings_ratio: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            bluechip_total_holders: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            bluechip_total_holdings: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            bundle_holdings_ratio: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            bundle_total_holders: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            bundle_total_holdings: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            completion_ratio: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            dev_holdings_ratio: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            dev_total_holders: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            dev_total_holdings: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            fresh_holdings_ratio: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            fresh_total_holders: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            fresh_total_holdings: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            holders: ::std::result::Result<::std::string::String, ::std::string::String>,
            insider_holdings_ratio: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            insider_total_holders: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            insider_total_holdings: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            kol_holdings_ratio: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            kol_total_holders: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            kol_total_holdings: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            market_cap_in_sol: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            market_cap_in_usd: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            max_pool_tvl_in_sol: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            max_pool_tvl_in_usd: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            price_in_sol: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            price_in_usd: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            pro_holdings_ratio: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            pro_total_holders: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            pro_total_holdings: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            sandwish_holdings_ratio: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            sandwish_total_holders: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            sandwish_total_holdings: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            sniper_holdings_ratio: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            sniper_total_holders: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            sniper_total_holdings: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            top100_holdings_ratio: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            top100_total_holdings: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            top10_holdings_ratio: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            top10_total_holdings: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            top50_holdings_ratio: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            top50_total_holdings: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            total_supply: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            total_tvl_in_sol: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            total_tvl_in_usd: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for TokenMarketData {
            fn default() -> Self {
                Self {
                    bluechip_holdings_ratio: Ok(Default::default()),
                    bluechip_total_holders: Ok(Default::default()),
                    bluechip_total_holdings: Ok(Default::default()),
                    bundle_holdings_ratio: Ok(Default::default()),
                    bundle_total_holders: Ok(Default::default()),
                    bundle_total_holdings: Ok(Default::default()),
                    completion_ratio: Ok(Default::default()),
                    dev_holdings_ratio: Ok(Default::default()),
                    dev_total_holders: Ok(Default::default()),
                    dev_total_holdings: Ok(Default::default()),
                    fresh_holdings_ratio: Ok(Default::default()),
                    fresh_total_holders: Ok(Default::default()),
                    fresh_total_holdings: Ok(Default::default()),
                    holders: Err("no value supplied for holders".to_string()),
                    insider_holdings_ratio: Ok(Default::default()),
                    insider_total_holders: Ok(Default::default()),
                    insider_total_holdings: Ok(Default::default()),
                    kol_holdings_ratio: Ok(Default::default()),
                    kol_total_holders: Ok(Default::default()),
                    kol_total_holdings: Ok(Default::default()),
                    market_cap_in_sol: Ok(Default::default()),
                    market_cap_in_usd: Err(
                        "no value supplied for market_cap_in_usd".to_string(),
                    ),
                    max_pool_tvl_in_sol: Ok(Default::default()),
                    max_pool_tvl_in_usd: Ok(Default::default()),
                    price_in_sol: Ok(Default::default()),
                    price_in_usd: Err("no value supplied for price_in_usd".to_string()),
                    pro_holdings_ratio: Ok(Default::default()),
                    pro_total_holders: Ok(Default::default()),
                    pro_total_holdings: Ok(Default::default()),
                    sandwish_holdings_ratio: Ok(Default::default()),
                    sandwish_total_holders: Ok(Default::default()),
                    sandwish_total_holdings: Ok(Default::default()),
                    sniper_holdings_ratio: Ok(Default::default()),
                    sniper_total_holders: Ok(Default::default()),
                    sniper_total_holdings: Ok(Default::default()),
                    top100_holdings_ratio: Ok(Default::default()),
                    top100_total_holdings: Ok(Default::default()),
                    top10_holdings_ratio: Ok(Default::default()),
                    top10_total_holdings: Ok(Default::default()),
                    top50_holdings_ratio: Ok(Default::default()),
                    top50_total_holdings: Ok(Default::default()),
                    total_supply: Err("no value supplied for total_supply".to_string()),
                    total_tvl_in_sol: Err(
                        "no value supplied for total_tvl_in_sol".to_string(),
                    ),
                    total_tvl_in_usd: Err(
                        "no value supplied for total_tvl_in_usd".to_string(),
                    ),
                }
            }
        }
        impl TokenMarketData {
            pub fn bluechip_holdings_ratio<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.bluechip_holdings_ratio = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for bluechip_holdings_ratio: {}",
                            e
                        )
                    });
                self
            }
            pub fn bluechip_total_holders<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.bluechip_total_holders = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for bluechip_total_holders: {}",
                            e
                        )
                    });
                self
            }
            pub fn bluechip_total_holdings<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.bluechip_total_holdings = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for bluechip_total_holdings: {}",
                            e
                        )
                    });
                self
            }
            pub fn bundle_holdings_ratio<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.bundle_holdings_ratio = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for bundle_holdings_ratio: {}",
                            e
                        )
                    });
                self
            }
            pub fn bundle_total_holders<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.bundle_total_holders = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for bundle_total_holders: {}",
                            e
                        )
                    });
                self
            }
            pub fn bundle_total_holdings<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.bundle_total_holdings = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for bundle_total_holdings: {}",
                            e
                        )
                    });
                self
            }
            pub fn completion_ratio<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.completion_ratio = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for completion_ratio: {}", e
                        )
                    });
                self
            }
            pub fn dev_holdings_ratio<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.dev_holdings_ratio = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for dev_holdings_ratio: {}",
                            e
                        )
                    });
                self
            }
            pub fn dev_total_holders<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.dev_total_holders = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for dev_total_holders: {}",
                            e
                        )
                    });
                self
            }
            pub fn dev_total_holdings<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.dev_total_holdings = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for dev_total_holdings: {}",
                            e
                        )
                    });
                self
            }
            pub fn fresh_holdings_ratio<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.fresh_holdings_ratio = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for fresh_holdings_ratio: {}",
                            e
                        )
                    });
                self
            }
            pub fn fresh_total_holders<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.fresh_total_holders = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for fresh_total_holders: {}",
                            e
                        )
                    });
                self
            }
            pub fn fresh_total_holdings<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.fresh_total_holdings = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for fresh_total_holdings: {}",
                            e
                        )
                    });
                self
            }
            pub fn holders<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.holders = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for holders: {}", e)
                    });
                self
            }
            pub fn insider_holdings_ratio<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.insider_holdings_ratio = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for insider_holdings_ratio: {}",
                            e
                        )
                    });
                self
            }
            pub fn insider_total_holders<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.insider_total_holders = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for insider_total_holders: {}",
                            e
                        )
                    });
                self
            }
            pub fn insider_total_holdings<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.insider_total_holdings = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for insider_total_holdings: {}",
                            e
                        )
                    });
                self
            }
            pub fn kol_holdings_ratio<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.kol_holdings_ratio = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for kol_holdings_ratio: {}",
                            e
                        )
                    });
                self
            }
            pub fn kol_total_holders<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.kol_total_holders = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for kol_total_holders: {}",
                            e
                        )
                    });
                self
            }
            pub fn kol_total_holdings<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.kol_total_holdings = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for kol_total_holdings: {}",
                            e
                        )
                    });
                self
            }
            pub fn market_cap_in_sol<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.market_cap_in_sol = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for market_cap_in_sol: {}",
                            e
                        )
                    });
                self
            }
            pub fn market_cap_in_usd<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.market_cap_in_usd = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for market_cap_in_usd: {}",
                            e
                        )
                    });
                self
            }
            pub fn max_pool_tvl_in_sol<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.max_pool_tvl_in_sol = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for max_pool_tvl_in_sol: {}",
                            e
                        )
                    });
                self
            }
            pub fn max_pool_tvl_in_usd<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.max_pool_tvl_in_usd = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for max_pool_tvl_in_usd: {}",
                            e
                        )
                    });
                self
            }
            pub fn price_in_sol<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.price_in_sol = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for price_in_sol: {}", e
                        )
                    });
                self
            }
            pub fn price_in_usd<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.price_in_usd = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for price_in_usd: {}", e
                        )
                    });
                self
            }
            pub fn pro_holdings_ratio<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.pro_holdings_ratio = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for pro_holdings_ratio: {}",
                            e
                        )
                    });
                self
            }
            pub fn pro_total_holders<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.pro_total_holders = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for pro_total_holders: {}",
                            e
                        )
                    });
                self
            }
            pub fn pro_total_holdings<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.pro_total_holdings = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for pro_total_holdings: {}",
                            e
                        )
                    });
                self
            }
            pub fn sandwish_holdings_ratio<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.sandwish_holdings_ratio = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for sandwish_holdings_ratio: {}",
                            e
                        )
                    });
                self
            }
            pub fn sandwish_total_holders<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.sandwish_total_holders = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for sandwish_total_holders: {}",
                            e
                        )
                    });
                self
            }
            pub fn sandwish_total_holdings<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.sandwish_total_holdings = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for sandwish_total_holdings: {}",
                            e
                        )
                    });
                self
            }
            pub fn sniper_holdings_ratio<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.sniper_holdings_ratio = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for sniper_holdings_ratio: {}",
                            e
                        )
                    });
                self
            }
            pub fn sniper_total_holders<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.sniper_total_holders = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for sniper_total_holders: {}",
                            e
                        )
                    });
                self
            }
            pub fn sniper_total_holdings<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.sniper_total_holdings = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for sniper_total_holdings: {}",
                            e
                        )
                    });
                self
            }
            pub fn top100_holdings_ratio<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.top100_holdings_ratio = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for top100_holdings_ratio: {}",
                            e
                        )
                    });
                self
            }
            pub fn top100_total_holdings<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.top100_total_holdings = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for top100_total_holdings: {}",
                            e
                        )
                    });
                self
            }
            pub fn top10_holdings_ratio<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.top10_holdings_ratio = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for top10_holdings_ratio: {}",
                            e
                        )
                    });
                self
            }
            pub fn top10_total_holdings<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.top10_total_holdings = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for top10_total_holdings: {}",
                            e
                        )
                    });
                self
            }
            pub fn top50_holdings_ratio<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.top50_holdings_ratio = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for top50_holdings_ratio: {}",
                            e
                        )
                    });
                self
            }
            pub fn top50_total_holdings<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.top50_total_holdings = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for top50_total_holdings: {}",
                            e
                        )
                    });
                self
            }
            pub fn total_supply<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.total_supply = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for total_supply: {}", e
                        )
                    });
                self
            }
            pub fn total_tvl_in_sol<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.total_tvl_in_sol = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for total_tvl_in_sol: {}", e
                        )
                    });
                self
            }
            pub fn total_tvl_in_usd<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.total_tvl_in_usd = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for total_tvl_in_usd: {}", e
                        )
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<TokenMarketData> for super::TokenMarketData {
            type Error = super::error::ConversionError;
            fn try_from(
                value: TokenMarketData,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    bluechip_holdings_ratio: value.bluechip_holdings_ratio?,
                    bluechip_total_holders: value.bluechip_total_holders?,
                    bluechip_total_holdings: value.bluechip_total_holdings?,
                    bundle_holdings_ratio: value.bundle_holdings_ratio?,
                    bundle_total_holders: value.bundle_total_holders?,
                    bundle_total_holdings: value.bundle_total_holdings?,
                    completion_ratio: value.completion_ratio?,
                    dev_holdings_ratio: value.dev_holdings_ratio?,
                    dev_total_holders: value.dev_total_holders?,
                    dev_total_holdings: value.dev_total_holdings?,
                    fresh_holdings_ratio: value.fresh_holdings_ratio?,
                    fresh_total_holders: value.fresh_total_holders?,
                    fresh_total_holdings: value.fresh_total_holdings?,
                    holders: value.holders?,
                    insider_holdings_ratio: value.insider_holdings_ratio?,
                    insider_total_holders: value.insider_total_holders?,
                    insider_total_holdings: value.insider_total_holdings?,
                    kol_holdings_ratio: value.kol_holdings_ratio?,
                    kol_total_holders: value.kol_total_holders?,
                    kol_total_holdings: value.kol_total_holdings?,
                    market_cap_in_sol: value.market_cap_in_sol?,
                    market_cap_in_usd: value.market_cap_in_usd?,
                    max_pool_tvl_in_sol: value.max_pool_tvl_in_sol?,
                    max_pool_tvl_in_usd: value.max_pool_tvl_in_usd?,
                    price_in_sol: value.price_in_sol?,
                    price_in_usd: value.price_in_usd?,
                    pro_holdings_ratio: value.pro_holdings_ratio?,
                    pro_total_holders: value.pro_total_holders?,
                    pro_total_holdings: value.pro_total_holdings?,
                    sandwish_holdings_ratio: value.sandwish_holdings_ratio?,
                    sandwish_total_holders: value.sandwish_total_holders?,
                    sandwish_total_holdings: value.sandwish_total_holdings?,
                    sniper_holdings_ratio: value.sniper_holdings_ratio?,
                    sniper_total_holders: value.sniper_total_holders?,
                    sniper_total_holdings: value.sniper_total_holdings?,
                    top100_holdings_ratio: value.top100_holdings_ratio?,
                    top100_total_holdings: value.top100_total_holdings?,
                    top10_holdings_ratio: value.top10_holdings_ratio?,
                    top10_total_holdings: value.top10_total_holdings?,
                    top50_holdings_ratio: value.top50_holdings_ratio?,
                    top50_total_holdings: value.top50_total_holdings?,
                    total_supply: value.total_supply?,
                    total_tvl_in_sol: value.total_tvl_in_sol?,
                    total_tvl_in_usd: value.total_tvl_in_usd?,
                })
            }
        }
        impl ::std::convert::From<super::TokenMarketData> for TokenMarketData {
            fn from(value: super::TokenMarketData) -> Self {
                Self {
                    bluechip_holdings_ratio: Ok(value.bluechip_holdings_ratio),
                    bluechip_total_holders: Ok(value.bluechip_total_holders),
                    bluechip_total_holdings: Ok(value.bluechip_total_holdings),
                    bundle_holdings_ratio: Ok(value.bundle_holdings_ratio),
                    bundle_total_holders: Ok(value.bundle_total_holders),
                    bundle_total_holdings: Ok(value.bundle_total_holdings),
                    completion_ratio: Ok(value.completion_ratio),
                    dev_holdings_ratio: Ok(value.dev_holdings_ratio),
                    dev_total_holders: Ok(value.dev_total_holders),
                    dev_total_holdings: Ok(value.dev_total_holdings),
                    fresh_holdings_ratio: Ok(value.fresh_holdings_ratio),
                    fresh_total_holders: Ok(value.fresh_total_holders),
                    fresh_total_holdings: Ok(value.fresh_total_holdings),
                    holders: Ok(value.holders),
                    insider_holdings_ratio: Ok(value.insider_holdings_ratio),
                    insider_total_holders: Ok(value.insider_total_holders),
                    insider_total_holdings: Ok(value.insider_total_holdings),
                    kol_holdings_ratio: Ok(value.kol_holdings_ratio),
                    kol_total_holders: Ok(value.kol_total_holders),
                    kol_total_holdings: Ok(value.kol_total_holdings),
                    market_cap_in_sol: Ok(value.market_cap_in_sol),
                    market_cap_in_usd: Ok(value.market_cap_in_usd),
                    max_pool_tvl_in_sol: Ok(value.max_pool_tvl_in_sol),
                    max_pool_tvl_in_usd: Ok(value.max_pool_tvl_in_usd),
                    price_in_sol: Ok(value.price_in_sol),
                    price_in_usd: Ok(value.price_in_usd),
                    pro_holdings_ratio: Ok(value.pro_holdings_ratio),
                    pro_total_holders: Ok(value.pro_total_holders),
                    pro_total_holdings: Ok(value.pro_total_holdings),
                    sandwish_holdings_ratio: Ok(value.sandwish_holdings_ratio),
                    sandwish_total_holders: Ok(value.sandwish_total_holders),
                    sandwish_total_holdings: Ok(value.sandwish_total_holdings),
                    sniper_holdings_ratio: Ok(value.sniper_holdings_ratio),
                    sniper_total_holders: Ok(value.sniper_total_holders),
                    sniper_total_holdings: Ok(value.sniper_total_holdings),
                    top100_holdings_ratio: Ok(value.top100_holdings_ratio),
                    top100_total_holdings: Ok(value.top100_total_holdings),
                    top10_holdings_ratio: Ok(value.top10_holdings_ratio),
                    top10_total_holdings: Ok(value.top10_total_holdings),
                    top50_holdings_ratio: Ok(value.top50_holdings_ratio),
                    top50_total_holdings: Ok(value.top50_total_holdings),
                    total_supply: Ok(value.total_supply),
                    total_tvl_in_sol: Ok(value.total_tvl_in_sol),
                    total_tvl_in_usd: Ok(value.total_tvl_in_usd),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct TokenMetadata {
            address: ::std::result::Result<::std::string::String, ::std::string::String>,
            chain: ::std::result::Result<::std::string::String, ::std::string::String>,
            coingecko_coin_id: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            decimals: ::std::result::Result<i64, ::std::string::String>,
            description: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            dev_last_token_created_at: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            dev_total_tokens: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            extra: ::std::result::Result<
                ::std::option::Option<super::TokenExtraDto>,
                ::std::string::String,
            >,
            image_url: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            metadata_address: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            name: ::std::result::Result<::std::string::String, ::std::string::String>,
            social_medias: ::std::result::Result<
                ::std::option::Option<super::TokenSocialMediasDto>,
                ::std::string::String,
            >,
            symbol: ::std::result::Result<::std::string::String, ::std::string::String>,
            token_created_at: ::std::result::Result<
                ::std::option::Option<i64>,
                ::std::string::String,
            >,
            token_created_block_height: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            token_created_slot: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            token_created_tx_signature: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            token_creators: ::std::result::Result<
                ::std::vec::Vec<super::TokenCreatorsDto>,
                ::std::string::String,
            >,
            uri: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for TokenMetadata {
            fn default() -> Self {
                Self {
                    address: Err("no value supplied for address".to_string()),
                    chain: Err("no value supplied for chain".to_string()),
                    coingecko_coin_id: Ok(Default::default()),
                    decimals: Err("no value supplied for decimals".to_string()),
                    description: Ok(Default::default()),
                    dev_last_token_created_at: Ok(Default::default()),
                    dev_total_tokens: Ok(Default::default()),
                    extra: Ok(Default::default()),
                    image_url: Ok(Default::default()),
                    metadata_address: Ok(Default::default()),
                    name: Err("no value supplied for name".to_string()),
                    social_medias: Ok(Default::default()),
                    symbol: Err("no value supplied for symbol".to_string()),
                    token_created_at: Ok(Default::default()),
                    token_created_block_height: Ok(Default::default()),
                    token_created_slot: Ok(Default::default()),
                    token_created_tx_signature: Ok(Default::default()),
                    token_creators: Ok(Default::default()),
                    uri: Ok(Default::default()),
                }
            }
        }
        impl TokenMetadata {
            pub fn address<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.address = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for address: {}", e)
                    });
                self
            }
            pub fn chain<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.chain = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for chain: {}", e)
                    });
                self
            }
            pub fn coingecko_coin_id<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.coingecko_coin_id = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for coingecko_coin_id: {}",
                            e
                        )
                    });
                self
            }
            pub fn decimals<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<i64>,
                T::Error: ::std::fmt::Display,
            {
                self.decimals = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for decimals: {}", e)
                    });
                self
            }
            pub fn description<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.description = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for description: {}", e)
                    });
                self
            }
            pub fn dev_last_token_created_at<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.dev_last_token_created_at = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for dev_last_token_created_at: {}",
                            e
                        )
                    });
                self
            }
            pub fn dev_total_tokens<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.dev_total_tokens = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for dev_total_tokens: {}", e
                        )
                    });
                self
            }
            pub fn extra<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<super::TokenExtraDto>>,
                T::Error: ::std::fmt::Display,
            {
                self.extra = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for extra: {}", e)
                    });
                self
            }
            pub fn image_url<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.image_url = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for image_url: {}", e)
                    });
                self
            }
            pub fn metadata_address<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.metadata_address = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for metadata_address: {}", e
                        )
                    });
                self
            }
            pub fn name<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.name = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for name: {}", e)
                    });
                self
            }
            pub fn social_medias<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<
                    ::std::option::Option<super::TokenSocialMediasDto>,
                >,
                T::Error: ::std::fmt::Display,
            {
                self.social_medias = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for social_medias: {}", e
                        )
                    });
                self
            }
            pub fn symbol<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.symbol = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for symbol: {}", e)
                    });
                self
            }
            pub fn token_created_at<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<i64>>,
                T::Error: ::std::fmt::Display,
            {
                self.token_created_at = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for token_created_at: {}", e
                        )
                    });
                self
            }
            pub fn token_created_block_height<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.token_created_block_height = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for token_created_block_height: {}",
                            e
                        )
                    });
                self
            }
            pub fn token_created_slot<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.token_created_slot = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for token_created_slot: {}",
                            e
                        )
                    });
                self
            }
            pub fn token_created_tx_signature<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.token_created_tx_signature = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for token_created_tx_signature: {}",
                            e
                        )
                    });
                self
            }
            pub fn token_creators<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::vec::Vec<super::TokenCreatorsDto>>,
                T::Error: ::std::fmt::Display,
            {
                self.token_creators = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for token_creators: {}", e
                        )
                    });
                self
            }
            pub fn uri<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.uri = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for uri: {}", e)
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<TokenMetadata> for super::TokenMetadata {
            type Error = super::error::ConversionError;
            fn try_from(
                value: TokenMetadata,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    address: value.address?,
                    chain: value.chain?,
                    coingecko_coin_id: value.coingecko_coin_id?,
                    decimals: value.decimals?,
                    description: value.description?,
                    dev_last_token_created_at: value.dev_last_token_created_at?,
                    dev_total_tokens: value.dev_total_tokens?,
                    extra: value.extra?,
                    image_url: value.image_url?,
                    metadata_address: value.metadata_address?,
                    name: value.name?,
                    social_medias: value.social_medias?,
                    symbol: value.symbol?,
                    token_created_at: value.token_created_at?,
                    token_created_block_height: value.token_created_block_height?,
                    token_created_slot: value.token_created_slot?,
                    token_created_tx_signature: value.token_created_tx_signature?,
                    token_creators: value.token_creators?,
                    uri: value.uri?,
                })
            }
        }
        impl ::std::convert::From<super::TokenMetadata> for TokenMetadata {
            fn from(value: super::TokenMetadata) -> Self {
                Self {
                    address: Ok(value.address),
                    chain: Ok(value.chain),
                    coingecko_coin_id: Ok(value.coingecko_coin_id),
                    decimals: Ok(value.decimals),
                    description: Ok(value.description),
                    dev_last_token_created_at: Ok(value.dev_last_token_created_at),
                    dev_total_tokens: Ok(value.dev_total_tokens),
                    extra: Ok(value.extra),
                    image_url: Ok(value.image_url),
                    metadata_address: Ok(value.metadata_address),
                    name: Ok(value.name),
                    social_medias: Ok(value.social_medias),
                    symbol: Ok(value.symbol),
                    token_created_at: Ok(value.token_created_at),
                    token_created_block_height: Ok(value.token_created_block_height),
                    token_created_slot: Ok(value.token_created_slot),
                    token_created_tx_signature: Ok(value.token_created_tx_signature),
                    token_creators: Ok(value.token_creators),
                    uri: Ok(value.uri),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct TokenPage {
            counts_by_protocols: ::std::result::Result<
                ::serde_json::Map<::std::string::String, ::serde_json::Value>,
                ::std::string::String,
            >,
            data: ::std::result::Result<
                ::std::vec::Vec<super::Token>,
                ::std::string::String,
            >,
            end_cursor: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            has_next: ::std::result::Result<bool, ::std::string::String>,
            has_prev: ::std::result::Result<bool, ::std::string::String>,
            start_cursor: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            total: ::std::result::Result<i64, ::std::string::String>,
        }
        impl ::std::default::Default for TokenPage {
            fn default() -> Self {
                Self {
                    counts_by_protocols: Ok(Default::default()),
                    data: Err("no value supplied for data".to_string()),
                    end_cursor: Ok(Default::default()),
                    has_next: Ok(Default::default()),
                    has_prev: Ok(Default::default()),
                    start_cursor: Ok(Default::default()),
                    total: Ok(Default::default()),
                }
            }
        }
        impl TokenPage {
            pub fn counts_by_protocols<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<
                    ::serde_json::Map<::std::string::String, ::serde_json::Value>,
                >,
                T::Error: ::std::fmt::Display,
            {
                self.counts_by_protocols = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for counts_by_protocols: {}",
                            e
                        )
                    });
                self
            }
            pub fn data<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::vec::Vec<super::Token>>,
                T::Error: ::std::fmt::Display,
            {
                self.data = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for data: {}", e)
                    });
                self
            }
            pub fn end_cursor<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.end_cursor = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for end_cursor: {}", e)
                    });
                self
            }
            pub fn has_next<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<bool>,
                T::Error: ::std::fmt::Display,
            {
                self.has_next = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for has_next: {}", e)
                    });
                self
            }
            pub fn has_prev<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<bool>,
                T::Error: ::std::fmt::Display,
            {
                self.has_prev = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for has_prev: {}", e)
                    });
                self
            }
            pub fn start_cursor<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.start_cursor = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for start_cursor: {}", e
                        )
                    });
                self
            }
            pub fn total<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<i64>,
                T::Error: ::std::fmt::Display,
            {
                self.total = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for total: {}", e)
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<TokenPage> for super::TokenPage {
            type Error = super::error::ConversionError;
            fn try_from(
                value: TokenPage,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    counts_by_protocols: value.counts_by_protocols?,
                    data: value.data?,
                    end_cursor: value.end_cursor?,
                    has_next: value.has_next?,
                    has_prev: value.has_prev?,
                    start_cursor: value.start_cursor?,
                    total: value.total?,
                })
            }
        }
        impl ::std::convert::From<super::TokenPage> for TokenPage {
            fn from(value: super::TokenPage) -> Self {
                Self {
                    counts_by_protocols: Ok(value.counts_by_protocols),
                    data: Ok(value.data),
                    end_cursor: Ok(value.end_cursor),
                    has_next: Ok(value.has_next),
                    has_prev: Ok(value.has_prev),
                    start_cursor: Ok(value.start_cursor),
                    total: Ok(value.total),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct TokenPriceDto {
            price_in_native: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            price_in_usd: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            timestamp: ::std::result::Result<i64, ::std::string::String>,
            token_address: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for TokenPriceDto {
            fn default() -> Self {
                Self {
                    price_in_native: Err(
                        "no value supplied for price_in_native".to_string(),
                    ),
                    price_in_usd: Err("no value supplied for price_in_usd".to_string()),
                    timestamp: Err("no value supplied for timestamp".to_string()),
                    token_address: Err("no value supplied for token_address".to_string()),
                }
            }
        }
        impl TokenPriceDto {
            pub fn price_in_native<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.price_in_native = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for price_in_native: {}", e
                        )
                    });
                self
            }
            pub fn price_in_usd<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.price_in_usd = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for price_in_usd: {}", e
                        )
                    });
                self
            }
            pub fn timestamp<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<i64>,
                T::Error: ::std::fmt::Display,
            {
                self.timestamp = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for timestamp: {}", e)
                    });
                self
            }
            pub fn token_address<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.token_address = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for token_address: {}", e
                        )
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<TokenPriceDto> for super::TokenPriceDto {
            type Error = super::error::ConversionError;
            fn try_from(
                value: TokenPriceDto,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    price_in_native: value.price_in_native?,
                    price_in_usd: value.price_in_usd?,
                    timestamp: value.timestamp?,
                    token_address: value.token_address?,
                })
            }
        }
        impl ::std::convert::From<super::TokenPriceDto> for TokenPriceDto {
            fn from(value: super::TokenPriceDto) -> Self {
                Self {
                    price_in_native: Ok(value.price_in_native),
                    price_in_usd: Ok(value.price_in_usd),
                    timestamp: Ok(value.timestamp),
                    token_address: Ok(value.token_address),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct TokenPricePage {
            data: ::std::result::Result<
                ::std::vec::Vec<super::TokenPriceDto>,
                ::std::string::String,
            >,
            end_cursor: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            has_next: ::std::result::Result<bool, ::std::string::String>,
            has_prev: ::std::result::Result<bool, ::std::string::String>,
            start_cursor: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            total: ::std::result::Result<i64, ::std::string::String>,
        }
        impl ::std::default::Default for TokenPricePage {
            fn default() -> Self {
                Self {
                    data: Err("no value supplied for data".to_string()),
                    end_cursor: Ok(Default::default()),
                    has_next: Ok(Default::default()),
                    has_prev: Ok(Default::default()),
                    start_cursor: Ok(Default::default()),
                    total: Ok(Default::default()),
                }
            }
        }
        impl TokenPricePage {
            pub fn data<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::vec::Vec<super::TokenPriceDto>>,
                T::Error: ::std::fmt::Display,
            {
                self.data = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for data: {}", e)
                    });
                self
            }
            pub fn end_cursor<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.end_cursor = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for end_cursor: {}", e)
                    });
                self
            }
            pub fn has_next<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<bool>,
                T::Error: ::std::fmt::Display,
            {
                self.has_next = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for has_next: {}", e)
                    });
                self
            }
            pub fn has_prev<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<bool>,
                T::Error: ::std::fmt::Display,
            {
                self.has_prev = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for has_prev: {}", e)
                    });
                self
            }
            pub fn start_cursor<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.start_cursor = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for start_cursor: {}", e
                        )
                    });
                self
            }
            pub fn total<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<i64>,
                T::Error: ::std::fmt::Display,
            {
                self.total = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for total: {}", e)
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<TokenPricePage> for super::TokenPricePage {
            type Error = super::error::ConversionError;
            fn try_from(
                value: TokenPricePage,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    data: value.data?,
                    end_cursor: value.end_cursor?,
                    has_next: value.has_next?,
                    has_prev: value.has_prev?,
                    start_cursor: value.start_cursor?,
                    total: value.total?,
                })
            }
        }
        impl ::std::convert::From<super::TokenPricePage> for TokenPricePage {
            fn from(value: super::TokenPricePage) -> Self {
                Self {
                    data: Ok(value.data),
                    end_cursor: Ok(value.end_cursor),
                    has_next: Ok(value.has_next),
                    has_prev: Ok(value.has_prev),
                    start_cursor: Ok(value.start_cursor),
                    total: Ok(value.total),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct TokenSocialMediasDto {
            bitbucket: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            discord: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            facebook: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            github: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            instagram: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            linkedin: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            medium: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            reddit: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            telegram: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            tiktok: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            twitter: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            website: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            youtube: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for TokenSocialMediasDto {
            fn default() -> Self {
                Self {
                    bitbucket: Ok(Default::default()),
                    discord: Ok(Default::default()),
                    facebook: Ok(Default::default()),
                    github: Ok(Default::default()),
                    instagram: Ok(Default::default()),
                    linkedin: Ok(Default::default()),
                    medium: Ok(Default::default()),
                    reddit: Ok(Default::default()),
                    telegram: Ok(Default::default()),
                    tiktok: Ok(Default::default()),
                    twitter: Ok(Default::default()),
                    website: Ok(Default::default()),
                    youtube: Ok(Default::default()),
                }
            }
        }
        impl TokenSocialMediasDto {
            pub fn bitbucket<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.bitbucket = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for bitbucket: {}", e)
                    });
                self
            }
            pub fn discord<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.discord = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for discord: {}", e)
                    });
                self
            }
            pub fn facebook<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.facebook = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for facebook: {}", e)
                    });
                self
            }
            pub fn github<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.github = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for github: {}", e)
                    });
                self
            }
            pub fn instagram<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.instagram = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for instagram: {}", e)
                    });
                self
            }
            pub fn linkedin<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.linkedin = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for linkedin: {}", e)
                    });
                self
            }
            pub fn medium<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.medium = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for medium: {}", e)
                    });
                self
            }
            pub fn reddit<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.reddit = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for reddit: {}", e)
                    });
                self
            }
            pub fn telegram<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.telegram = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for telegram: {}", e)
                    });
                self
            }
            pub fn tiktok<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.tiktok = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for tiktok: {}", e)
                    });
                self
            }
            pub fn twitter<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.twitter = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for twitter: {}", e)
                    });
                self
            }
            pub fn website<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.website = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for website: {}", e)
                    });
                self
            }
            pub fn youtube<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.youtube = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for youtube: {}", e)
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<TokenSocialMediasDto>
        for super::TokenSocialMediasDto {
            type Error = super::error::ConversionError;
            fn try_from(
                value: TokenSocialMediasDto,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    bitbucket: value.bitbucket?,
                    discord: value.discord?,
                    facebook: value.facebook?,
                    github: value.github?,
                    instagram: value.instagram?,
                    linkedin: value.linkedin?,
                    medium: value.medium?,
                    reddit: value.reddit?,
                    telegram: value.telegram?,
                    tiktok: value.tiktok?,
                    twitter: value.twitter?,
                    website: value.website?,
                    youtube: value.youtube?,
                })
            }
        }
        impl ::std::convert::From<super::TokenSocialMediasDto> for TokenSocialMediasDto {
            fn from(value: super::TokenSocialMediasDto) -> Self {
                Self {
                    bitbucket: Ok(value.bitbucket),
                    discord: Ok(value.discord),
                    facebook: Ok(value.facebook),
                    github: Ok(value.github),
                    instagram: Ok(value.instagram),
                    linkedin: Ok(value.linkedin),
                    medium: Ok(value.medium),
                    reddit: Ok(value.reddit),
                    telegram: Ok(value.telegram),
                    tiktok: Ok(value.tiktok),
                    twitter: Ok(value.twitter),
                    website: Ok(value.website),
                    youtube: Ok(value.youtube),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct TokenStat {
            address: ::std::result::Result<::std::string::String, ::std::string::String>,
            periods: ::std::result::Result<
                ::std::collections::HashMap<
                    ::std::string::String,
                    super::TokenTradeStatPeriod,
                >,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for TokenStat {
            fn default() -> Self {
                Self {
                    address: Err("no value supplied for address".to_string()),
                    periods: Err("no value supplied for periods".to_string()),
                }
            }
        }
        impl TokenStat {
            pub fn address<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.address = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for address: {}", e)
                    });
                self
            }
            pub fn periods<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<
                    ::std::collections::HashMap<
                        ::std::string::String,
                        super::TokenTradeStatPeriod,
                    >,
                >,
                T::Error: ::std::fmt::Display,
            {
                self.periods = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for periods: {}", e)
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<TokenStat> for super::TokenStat {
            type Error = super::error::ConversionError;
            fn try_from(
                value: TokenStat,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    address: value.address?,
                    periods: value.periods?,
                })
            }
        }
        impl ::std::convert::From<super::TokenStat> for TokenStat {
            fn from(value: super::TokenStat) -> Self {
                Self {
                    address: Ok(value.address),
                    periods: Ok(value.periods),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct TokenTradeStatPeriod {
            average_price_in_native: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            average_price_in_usd: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            buy_sell_ratio: ::std::result::Result<
                ::serde_json::Map<::std::string::String, ::serde_json::Value>,
                ::std::string::String,
            >,
            buy_volume: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            buy_volume_in_native: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            buy_volume_in_usd: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            buyers: ::std::result::Result<::std::string::String, ::std::string::String>,
            buys: ::std::result::Result<::std::string::String, ::std::string::String>,
            close_in_native: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            close_in_usd: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            current_liquidity_in_usd: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            dapp_program_count: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            high_in_native: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            high_in_usd: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            liquidity_change_ratio: ::std::result::Result<
                ::serde_json::Map<::std::string::String, ::serde_json::Value>,
                ::std::string::String,
            >,
            low_in_native: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            low_in_usd: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            open_in_native: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            open_in_usd: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            pool_count: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            prev_buy_volume: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            prev_buy_volume_in_native: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            prev_buy_volume_in_usd: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            prev_buyers: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            prev_buys: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            prev_close_in_native: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            prev_close_in_usd: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            prev_dapp_program_count: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            prev_high_in_native: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            prev_high_in_usd: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            prev_liquidity_in_usd: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            prev_low_in_native: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            prev_low_in_usd: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            prev_open_in_native: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            prev_open_in_usd: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            prev_pool_count: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            prev_sell_volume: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            prev_sell_volume_in_native: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            prev_sell_volume_in_usd: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            prev_sellers: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            prev_sells: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            prev_trades: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            price_change_ratio_in_usd: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            sell_volume: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            sell_volume_in_native: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            sell_volume_in_usd: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            sellers: ::std::result::Result<::std::string::String, ::std::string::String>,
            sells: ::std::result::Result<::std::string::String, ::std::string::String>,
            total_volume_in_native: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            total_volume_in_usd: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            traders: ::std::result::Result<::std::string::String, ::std::string::String>,
            trades: ::std::result::Result<::std::string::String, ::std::string::String>,
            updated_at: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            volume_change_ratio: ::std::result::Result<
                ::serde_json::Map<::std::string::String, ::serde_json::Value>,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for TokenTradeStatPeriod {
            fn default() -> Self {
                Self {
                    average_price_in_native: Err(
                        "no value supplied for average_price_in_native".to_string(),
                    ),
                    average_price_in_usd: Err(
                        "no value supplied for average_price_in_usd".to_string(),
                    ),
                    buy_sell_ratio: Ok(Default::default()),
                    buy_volume: Err("no value supplied for buy_volume".to_string()),
                    buy_volume_in_native: Err(
                        "no value supplied for buy_volume_in_native".to_string(),
                    ),
                    buy_volume_in_usd: Err(
                        "no value supplied for buy_volume_in_usd".to_string(),
                    ),
                    buyers: Err("no value supplied for buyers".to_string()),
                    buys: Err("no value supplied for buys".to_string()),
                    close_in_native: Err(
                        "no value supplied for close_in_native".to_string(),
                    ),
                    close_in_usd: Err("no value supplied for close_in_usd".to_string()),
                    current_liquidity_in_usd: Err(
                        "no value supplied for current_liquidity_in_usd".to_string(),
                    ),
                    dapp_program_count: Err(
                        "no value supplied for dapp_program_count".to_string(),
                    ),
                    high_in_native: Err(
                        "no value supplied for high_in_native".to_string(),
                    ),
                    high_in_usd: Err("no value supplied for high_in_usd".to_string()),
                    liquidity_change_ratio: Ok(Default::default()),
                    low_in_native: Err(
                        "no value supplied for low_in_native".to_string(),
                    ),
                    low_in_usd: Err("no value supplied for low_in_usd".to_string()),
                    open_in_native: Err(
                        "no value supplied for open_in_native".to_string(),
                    ),
                    open_in_usd: Err("no value supplied for open_in_usd".to_string()),
                    pool_count: Err("no value supplied for pool_count".to_string()),
                    prev_buy_volume: Err(
                        "no value supplied for prev_buy_volume".to_string(),
                    ),
                    prev_buy_volume_in_native: Err(
                        "no value supplied for prev_buy_volume_in_native".to_string(),
                    ),
                    prev_buy_volume_in_usd: Err(
                        "no value supplied for prev_buy_volume_in_usd".to_string(),
                    ),
                    prev_buyers: Err("no value supplied for prev_buyers".to_string()),
                    prev_buys: Err("no value supplied for prev_buys".to_string()),
                    prev_close_in_native: Err(
                        "no value supplied for prev_close_in_native".to_string(),
                    ),
                    prev_close_in_usd: Err(
                        "no value supplied for prev_close_in_usd".to_string(),
                    ),
                    prev_dapp_program_count: Err(
                        "no value supplied for prev_dapp_program_count".to_string(),
                    ),
                    prev_high_in_native: Err(
                        "no value supplied for prev_high_in_native".to_string(),
                    ),
                    prev_high_in_usd: Err(
                        "no value supplied for prev_high_in_usd".to_string(),
                    ),
                    prev_liquidity_in_usd: Err(
                        "no value supplied for prev_liquidity_in_usd".to_string(),
                    ),
                    prev_low_in_native: Err(
                        "no value supplied for prev_low_in_native".to_string(),
                    ),
                    prev_low_in_usd: Err(
                        "no value supplied for prev_low_in_usd".to_string(),
                    ),
                    prev_open_in_native: Err(
                        "no value supplied for prev_open_in_native".to_string(),
                    ),
                    prev_open_in_usd: Err(
                        "no value supplied for prev_open_in_usd".to_string(),
                    ),
                    prev_pool_count: Err(
                        "no value supplied for prev_pool_count".to_string(),
                    ),
                    prev_sell_volume: Err(
                        "no value supplied for prev_sell_volume".to_string(),
                    ),
                    prev_sell_volume_in_native: Err(
                        "no value supplied for prev_sell_volume_in_native".to_string(),
                    ),
                    prev_sell_volume_in_usd: Err(
                        "no value supplied for prev_sell_volume_in_usd".to_string(),
                    ),
                    prev_sellers: Err("no value supplied for prev_sellers".to_string()),
                    prev_sells: Err("no value supplied for prev_sells".to_string()),
                    prev_trades: Err("no value supplied for prev_trades".to_string()),
                    price_change_ratio_in_usd: Err(
                        "no value supplied for price_change_ratio_in_usd".to_string(),
                    ),
                    sell_volume: Err("no value supplied for sell_volume".to_string()),
                    sell_volume_in_native: Err(
                        "no value supplied for sell_volume_in_native".to_string(),
                    ),
                    sell_volume_in_usd: Err(
                        "no value supplied for sell_volume_in_usd".to_string(),
                    ),
                    sellers: Err("no value supplied for sellers".to_string()),
                    sells: Err("no value supplied for sells".to_string()),
                    total_volume_in_native: Err(
                        "no value supplied for total_volume_in_native".to_string(),
                    ),
                    total_volume_in_usd: Err(
                        "no value supplied for total_volume_in_usd".to_string(),
                    ),
                    traders: Err("no value supplied for traders".to_string()),
                    trades: Err("no value supplied for trades".to_string()),
                    updated_at: Ok(Default::default()),
                    volume_change_ratio: Ok(Default::default()),
                }
            }
        }
        impl TokenTradeStatPeriod {
            pub fn average_price_in_native<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.average_price_in_native = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for average_price_in_native: {}",
                            e
                        )
                    });
                self
            }
            pub fn average_price_in_usd<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.average_price_in_usd = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for average_price_in_usd: {}",
                            e
                        )
                    });
                self
            }
            pub fn buy_sell_ratio<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<
                    ::serde_json::Map<::std::string::String, ::serde_json::Value>,
                >,
                T::Error: ::std::fmt::Display,
            {
                self.buy_sell_ratio = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for buy_sell_ratio: {}", e
                        )
                    });
                self
            }
            pub fn buy_volume<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.buy_volume = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for buy_volume: {}", e)
                    });
                self
            }
            pub fn buy_volume_in_native<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.buy_volume_in_native = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for buy_volume_in_native: {}",
                            e
                        )
                    });
                self
            }
            pub fn buy_volume_in_usd<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.buy_volume_in_usd = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for buy_volume_in_usd: {}",
                            e
                        )
                    });
                self
            }
            pub fn buyers<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.buyers = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for buyers: {}", e)
                    });
                self
            }
            pub fn buys<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.buys = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for buys: {}", e)
                    });
                self
            }
            pub fn close_in_native<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.close_in_native = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for close_in_native: {}", e
                        )
                    });
                self
            }
            pub fn close_in_usd<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.close_in_usd = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for close_in_usd: {}", e
                        )
                    });
                self
            }
            pub fn current_liquidity_in_usd<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.current_liquidity_in_usd = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for current_liquidity_in_usd: {}",
                            e
                        )
                    });
                self
            }
            pub fn dapp_program_count<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.dapp_program_count = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for dapp_program_count: {}",
                            e
                        )
                    });
                self
            }
            pub fn high_in_native<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.high_in_native = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for high_in_native: {}", e
                        )
                    });
                self
            }
            pub fn high_in_usd<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.high_in_usd = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for high_in_usd: {}", e)
                    });
                self
            }
            pub fn liquidity_change_ratio<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<
                    ::serde_json::Map<::std::string::String, ::serde_json::Value>,
                >,
                T::Error: ::std::fmt::Display,
            {
                self.liquidity_change_ratio = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for liquidity_change_ratio: {}",
                            e
                        )
                    });
                self
            }
            pub fn low_in_native<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.low_in_native = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for low_in_native: {}", e
                        )
                    });
                self
            }
            pub fn low_in_usd<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.low_in_usd = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for low_in_usd: {}", e)
                    });
                self
            }
            pub fn open_in_native<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.open_in_native = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for open_in_native: {}", e
                        )
                    });
                self
            }
            pub fn open_in_usd<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.open_in_usd = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for open_in_usd: {}", e)
                    });
                self
            }
            pub fn pool_count<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.pool_count = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for pool_count: {}", e)
                    });
                self
            }
            pub fn prev_buy_volume<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.prev_buy_volume = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for prev_buy_volume: {}", e
                        )
                    });
                self
            }
            pub fn prev_buy_volume_in_native<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.prev_buy_volume_in_native = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for prev_buy_volume_in_native: {}",
                            e
                        )
                    });
                self
            }
            pub fn prev_buy_volume_in_usd<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.prev_buy_volume_in_usd = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for prev_buy_volume_in_usd: {}",
                            e
                        )
                    });
                self
            }
            pub fn prev_buyers<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.prev_buyers = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for prev_buyers: {}", e)
                    });
                self
            }
            pub fn prev_buys<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.prev_buys = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for prev_buys: {}", e)
                    });
                self
            }
            pub fn prev_close_in_native<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.prev_close_in_native = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for prev_close_in_native: {}",
                            e
                        )
                    });
                self
            }
            pub fn prev_close_in_usd<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.prev_close_in_usd = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for prev_close_in_usd: {}",
                            e
                        )
                    });
                self
            }
            pub fn prev_dapp_program_count<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.prev_dapp_program_count = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for prev_dapp_program_count: {}",
                            e
                        )
                    });
                self
            }
            pub fn prev_high_in_native<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.prev_high_in_native = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for prev_high_in_native: {}",
                            e
                        )
                    });
                self
            }
            pub fn prev_high_in_usd<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.prev_high_in_usd = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for prev_high_in_usd: {}", e
                        )
                    });
                self
            }
            pub fn prev_liquidity_in_usd<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.prev_liquidity_in_usd = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for prev_liquidity_in_usd: {}",
                            e
                        )
                    });
                self
            }
            pub fn prev_low_in_native<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.prev_low_in_native = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for prev_low_in_native: {}",
                            e
                        )
                    });
                self
            }
            pub fn prev_low_in_usd<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.prev_low_in_usd = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for prev_low_in_usd: {}", e
                        )
                    });
                self
            }
            pub fn prev_open_in_native<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.prev_open_in_native = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for prev_open_in_native: {}",
                            e
                        )
                    });
                self
            }
            pub fn prev_open_in_usd<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.prev_open_in_usd = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for prev_open_in_usd: {}", e
                        )
                    });
                self
            }
            pub fn prev_pool_count<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.prev_pool_count = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for prev_pool_count: {}", e
                        )
                    });
                self
            }
            pub fn prev_sell_volume<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.prev_sell_volume = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for prev_sell_volume: {}", e
                        )
                    });
                self
            }
            pub fn prev_sell_volume_in_native<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.prev_sell_volume_in_native = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for prev_sell_volume_in_native: {}",
                            e
                        )
                    });
                self
            }
            pub fn prev_sell_volume_in_usd<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.prev_sell_volume_in_usd = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for prev_sell_volume_in_usd: {}",
                            e
                        )
                    });
                self
            }
            pub fn prev_sellers<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.prev_sellers = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for prev_sellers: {}", e
                        )
                    });
                self
            }
            pub fn prev_sells<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.prev_sells = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for prev_sells: {}", e)
                    });
                self
            }
            pub fn prev_trades<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.prev_trades = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for prev_trades: {}", e)
                    });
                self
            }
            pub fn price_change_ratio_in_usd<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.price_change_ratio_in_usd = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for price_change_ratio_in_usd: {}",
                            e
                        )
                    });
                self
            }
            pub fn sell_volume<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.sell_volume = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for sell_volume: {}", e)
                    });
                self
            }
            pub fn sell_volume_in_native<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.sell_volume_in_native = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for sell_volume_in_native: {}",
                            e
                        )
                    });
                self
            }
            pub fn sell_volume_in_usd<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.sell_volume_in_usd = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for sell_volume_in_usd: {}",
                            e
                        )
                    });
                self
            }
            pub fn sellers<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.sellers = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for sellers: {}", e)
                    });
                self
            }
            pub fn sells<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.sells = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for sells: {}", e)
                    });
                self
            }
            pub fn total_volume_in_native<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.total_volume_in_native = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for total_volume_in_native: {}",
                            e
                        )
                    });
                self
            }
            pub fn total_volume_in_usd<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.total_volume_in_usd = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for total_volume_in_usd: {}",
                            e
                        )
                    });
                self
            }
            pub fn traders<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.traders = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for traders: {}", e)
                    });
                self
            }
            pub fn trades<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.trades = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for trades: {}", e)
                    });
                self
            }
            pub fn updated_at<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.updated_at = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for updated_at: {}", e)
                    });
                self
            }
            pub fn volume_change_ratio<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<
                    ::serde_json::Map<::std::string::String, ::serde_json::Value>,
                >,
                T::Error: ::std::fmt::Display,
            {
                self.volume_change_ratio = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for volume_change_ratio: {}",
                            e
                        )
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<TokenTradeStatPeriod>
        for super::TokenTradeStatPeriod {
            type Error = super::error::ConversionError;
            fn try_from(
                value: TokenTradeStatPeriod,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    average_price_in_native: value.average_price_in_native?,
                    average_price_in_usd: value.average_price_in_usd?,
                    buy_sell_ratio: value.buy_sell_ratio?,
                    buy_volume: value.buy_volume?,
                    buy_volume_in_native: value.buy_volume_in_native?,
                    buy_volume_in_usd: value.buy_volume_in_usd?,
                    buyers: value.buyers?,
                    buys: value.buys?,
                    close_in_native: value.close_in_native?,
                    close_in_usd: value.close_in_usd?,
                    current_liquidity_in_usd: value.current_liquidity_in_usd?,
                    dapp_program_count: value.dapp_program_count?,
                    high_in_native: value.high_in_native?,
                    high_in_usd: value.high_in_usd?,
                    liquidity_change_ratio: value.liquidity_change_ratio?,
                    low_in_native: value.low_in_native?,
                    low_in_usd: value.low_in_usd?,
                    open_in_native: value.open_in_native?,
                    open_in_usd: value.open_in_usd?,
                    pool_count: value.pool_count?,
                    prev_buy_volume: value.prev_buy_volume?,
                    prev_buy_volume_in_native: value.prev_buy_volume_in_native?,
                    prev_buy_volume_in_usd: value.prev_buy_volume_in_usd?,
                    prev_buyers: value.prev_buyers?,
                    prev_buys: value.prev_buys?,
                    prev_close_in_native: value.prev_close_in_native?,
                    prev_close_in_usd: value.prev_close_in_usd?,
                    prev_dapp_program_count: value.prev_dapp_program_count?,
                    prev_high_in_native: value.prev_high_in_native?,
                    prev_high_in_usd: value.prev_high_in_usd?,
                    prev_liquidity_in_usd: value.prev_liquidity_in_usd?,
                    prev_low_in_native: value.prev_low_in_native?,
                    prev_low_in_usd: value.prev_low_in_usd?,
                    prev_open_in_native: value.prev_open_in_native?,
                    prev_open_in_usd: value.prev_open_in_usd?,
                    prev_pool_count: value.prev_pool_count?,
                    prev_sell_volume: value.prev_sell_volume?,
                    prev_sell_volume_in_native: value.prev_sell_volume_in_native?,
                    prev_sell_volume_in_usd: value.prev_sell_volume_in_usd?,
                    prev_sellers: value.prev_sellers?,
                    prev_sells: value.prev_sells?,
                    prev_trades: value.prev_trades?,
                    price_change_ratio_in_usd: value.price_change_ratio_in_usd?,
                    sell_volume: value.sell_volume?,
                    sell_volume_in_native: value.sell_volume_in_native?,
                    sell_volume_in_usd: value.sell_volume_in_usd?,
                    sellers: value.sellers?,
                    sells: value.sells?,
                    total_volume_in_native: value.total_volume_in_native?,
                    total_volume_in_usd: value.total_volume_in_usd?,
                    traders: value.traders?,
                    trades: value.trades?,
                    updated_at: value.updated_at?,
                    volume_change_ratio: value.volume_change_ratio?,
                })
            }
        }
        impl ::std::convert::From<super::TokenTradeStatPeriod> for TokenTradeStatPeriod {
            fn from(value: super::TokenTradeStatPeriod) -> Self {
                Self {
                    average_price_in_native: Ok(value.average_price_in_native),
                    average_price_in_usd: Ok(value.average_price_in_usd),
                    buy_sell_ratio: Ok(value.buy_sell_ratio),
                    buy_volume: Ok(value.buy_volume),
                    buy_volume_in_native: Ok(value.buy_volume_in_native),
                    buy_volume_in_usd: Ok(value.buy_volume_in_usd),
                    buyers: Ok(value.buyers),
                    buys: Ok(value.buys),
                    close_in_native: Ok(value.close_in_native),
                    close_in_usd: Ok(value.close_in_usd),
                    current_liquidity_in_usd: Ok(value.current_liquidity_in_usd),
                    dapp_program_count: Ok(value.dapp_program_count),
                    high_in_native: Ok(value.high_in_native),
                    high_in_usd: Ok(value.high_in_usd),
                    liquidity_change_ratio: Ok(value.liquidity_change_ratio),
                    low_in_native: Ok(value.low_in_native),
                    low_in_usd: Ok(value.low_in_usd),
                    open_in_native: Ok(value.open_in_native),
                    open_in_usd: Ok(value.open_in_usd),
                    pool_count: Ok(value.pool_count),
                    prev_buy_volume: Ok(value.prev_buy_volume),
                    prev_buy_volume_in_native: Ok(value.prev_buy_volume_in_native),
                    prev_buy_volume_in_usd: Ok(value.prev_buy_volume_in_usd),
                    prev_buyers: Ok(value.prev_buyers),
                    prev_buys: Ok(value.prev_buys),
                    prev_close_in_native: Ok(value.prev_close_in_native),
                    prev_close_in_usd: Ok(value.prev_close_in_usd),
                    prev_dapp_program_count: Ok(value.prev_dapp_program_count),
                    prev_high_in_native: Ok(value.prev_high_in_native),
                    prev_high_in_usd: Ok(value.prev_high_in_usd),
                    prev_liquidity_in_usd: Ok(value.prev_liquidity_in_usd),
                    prev_low_in_native: Ok(value.prev_low_in_native),
                    prev_low_in_usd: Ok(value.prev_low_in_usd),
                    prev_open_in_native: Ok(value.prev_open_in_native),
                    prev_open_in_usd: Ok(value.prev_open_in_usd),
                    prev_pool_count: Ok(value.prev_pool_count),
                    prev_sell_volume: Ok(value.prev_sell_volume),
                    prev_sell_volume_in_native: Ok(value.prev_sell_volume_in_native),
                    prev_sell_volume_in_usd: Ok(value.prev_sell_volume_in_usd),
                    prev_sellers: Ok(value.prev_sellers),
                    prev_sells: Ok(value.prev_sells),
                    prev_trades: Ok(value.prev_trades),
                    price_change_ratio_in_usd: Ok(value.price_change_ratio_in_usd),
                    sell_volume: Ok(value.sell_volume),
                    sell_volume_in_native: Ok(value.sell_volume_in_native),
                    sell_volume_in_usd: Ok(value.sell_volume_in_usd),
                    sellers: Ok(value.sellers),
                    sells: Ok(value.sells),
                    total_volume_in_native: Ok(value.total_volume_in_native),
                    total_volume_in_usd: Ok(value.total_volume_in_usd),
                    traders: Ok(value.traders),
                    trades: Ok(value.trades),
                    updated_at: Ok(value.updated_at),
                    volume_change_ratio: Ok(value.volume_change_ratio),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct TokenTrader {
            address: ::std::result::Result<::std::string::String, ::std::string::String>,
            block_hash: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            block_height: ::std::result::Result<
                ::std::option::Option<i64>,
                ::std::string::String,
            >,
            block_slot: ::std::result::Result<
                ::std::option::Option<i64>,
                ::std::string::String,
            >,
            block_timestamp: ::std::result::Result<
                ::std::option::Option<::chrono::DateTime<::chrono::offset::Utc>>,
                ::std::string::String,
            >,
            onchain_created_at: ::std::result::Result<
                ::serde_json::Map<::std::string::String, ::serde_json::Value>,
                ::std::string::String,
            >,
            percentile_rank_trade_amount_in_usd: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            percentile_rank_trade_count: ::std::result::Result<
                ::std::option::Option<i64>,
                ::std::string::String,
            >,
            rank_trade_amount_in_usd: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            trade_amount_in_native: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            trade_amount_in_usd: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            trade_count: ::std::result::Result<
                ::std::option::Option<i64>,
                ::std::string::String,
            >,
            transaction_signature: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for TokenTrader {
            fn default() -> Self {
                Self {
                    address: Err("no value supplied for address".to_string()),
                    block_hash: Ok(Default::default()),
                    block_height: Ok(Default::default()),
                    block_slot: Ok(Default::default()),
                    block_timestamp: Ok(Default::default()),
                    onchain_created_at: Ok(Default::default()),
                    percentile_rank_trade_amount_in_usd: Ok(Default::default()),
                    percentile_rank_trade_count: Ok(Default::default()),
                    rank_trade_amount_in_usd: Ok(Default::default()),
                    trade_amount_in_native: Ok(Default::default()),
                    trade_amount_in_usd: Ok(Default::default()),
                    trade_count: Ok(Default::default()),
                    transaction_signature: Ok(Default::default()),
                }
            }
        }
        impl TokenTrader {
            pub fn address<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.address = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for address: {}", e)
                    });
                self
            }
            pub fn block_hash<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.block_hash = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for block_hash: {}", e)
                    });
                self
            }
            pub fn block_height<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<i64>>,
                T::Error: ::std::fmt::Display,
            {
                self.block_height = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for block_height: {}", e
                        )
                    });
                self
            }
            pub fn block_slot<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<i64>>,
                T::Error: ::std::fmt::Display,
            {
                self.block_slot = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for block_slot: {}", e)
                    });
                self
            }
            pub fn block_timestamp<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<
                    ::std::option::Option<::chrono::DateTime<::chrono::offset::Utc>>,
                >,
                T::Error: ::std::fmt::Display,
            {
                self.block_timestamp = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for block_timestamp: {}", e
                        )
                    });
                self
            }
            pub fn onchain_created_at<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<
                    ::serde_json::Map<::std::string::String, ::serde_json::Value>,
                >,
                T::Error: ::std::fmt::Display,
            {
                self.onchain_created_at = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for onchain_created_at: {}",
                            e
                        )
                    });
                self
            }
            pub fn percentile_rank_trade_amount_in_usd<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.percentile_rank_trade_amount_in_usd = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for percentile_rank_trade_amount_in_usd: {}",
                            e
                        )
                    });
                self
            }
            pub fn percentile_rank_trade_count<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<i64>>,
                T::Error: ::std::fmt::Display,
            {
                self.percentile_rank_trade_count = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for percentile_rank_trade_count: {}",
                            e
                        )
                    });
                self
            }
            pub fn rank_trade_amount_in_usd<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.rank_trade_amount_in_usd = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for rank_trade_amount_in_usd: {}",
                            e
                        )
                    });
                self
            }
            pub fn trade_amount_in_native<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.trade_amount_in_native = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for trade_amount_in_native: {}",
                            e
                        )
                    });
                self
            }
            pub fn trade_amount_in_usd<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.trade_amount_in_usd = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for trade_amount_in_usd: {}",
                            e
                        )
                    });
                self
            }
            pub fn trade_count<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<i64>>,
                T::Error: ::std::fmt::Display,
            {
                self.trade_count = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for trade_count: {}", e)
                    });
                self
            }
            pub fn transaction_signature<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.transaction_signature = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for transaction_signature: {}",
                            e
                        )
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<TokenTrader> for super::TokenTrader {
            type Error = super::error::ConversionError;
            fn try_from(
                value: TokenTrader,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    address: value.address?,
                    block_hash: value.block_hash?,
                    block_height: value.block_height?,
                    block_slot: value.block_slot?,
                    block_timestamp: value.block_timestamp?,
                    onchain_created_at: value.onchain_created_at?,
                    percentile_rank_trade_amount_in_usd: value
                        .percentile_rank_trade_amount_in_usd?,
                    percentile_rank_trade_count: value.percentile_rank_trade_count?,
                    rank_trade_amount_in_usd: value.rank_trade_amount_in_usd?,
                    trade_amount_in_native: value.trade_amount_in_native?,
                    trade_amount_in_usd: value.trade_amount_in_usd?,
                    trade_count: value.trade_count?,
                    transaction_signature: value.transaction_signature?,
                })
            }
        }
        impl ::std::convert::From<super::TokenTrader> for TokenTrader {
            fn from(value: super::TokenTrader) -> Self {
                Self {
                    address: Ok(value.address),
                    block_hash: Ok(value.block_hash),
                    block_height: Ok(value.block_height),
                    block_slot: Ok(value.block_slot),
                    block_timestamp: Ok(value.block_timestamp),
                    onchain_created_at: Ok(value.onchain_created_at),
                    percentile_rank_trade_amount_in_usd: Ok(
                        value.percentile_rank_trade_amount_in_usd,
                    ),
                    percentile_rank_trade_count: Ok(value.percentile_rank_trade_count),
                    rank_trade_amount_in_usd: Ok(value.rank_trade_amount_in_usd),
                    trade_amount_in_native: Ok(value.trade_amount_in_native),
                    trade_amount_in_usd: Ok(value.trade_amount_in_usd),
                    trade_count: Ok(value.trade_count),
                    transaction_signature: Ok(value.transaction_signature),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct TokenTransferItemDto {
            action: ::std::result::Result<::std::string::String, ::std::string::String>,
            amount: ::std::result::Result<::std::string::String, ::std::string::String>,
            block_number: ::std::result::Result<i64, ::std::string::String>,
            block_time: ::std::result::Result<i64, ::std::string::String>,
            decimals: ::std::result::Result<i64, ::std::string::String>,
            flow: ::std::result::Result<
                super::TokenTransferItemDtoFlow,
                ::std::string::String,
            >,
            from_address: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            from_token_account: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            logo_uri: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            name: ::std::result::Result<::std::string::String, ::std::string::String>,
            price: ::std::result::Result<::std::string::String, ::std::string::String>,
            symbol: ::std::result::Result<::std::string::String, ::std::string::String>,
            to_address: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            to_token_account: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            token_address: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            tx_hash: ::std::result::Result<::std::string::String, ::std::string::String>,
            value: ::std::result::Result<::std::string::String, ::std::string::String>,
        }
        impl ::std::default::Default for TokenTransferItemDto {
            fn default() -> Self {
                Self {
                    action: Err("no value supplied for action".to_string()),
                    amount: Err("no value supplied for amount".to_string()),
                    block_number: Err("no value supplied for block_number".to_string()),
                    block_time: Err("no value supplied for block_time".to_string()),
                    decimals: Err("no value supplied for decimals".to_string()),
                    flow: Err("no value supplied for flow".to_string()),
                    from_address: Err("no value supplied for from_address".to_string()),
                    from_token_account: Err(
                        "no value supplied for from_token_account".to_string(),
                    ),
                    logo_uri: Ok(Default::default()),
                    name: Err("no value supplied for name".to_string()),
                    price: Err("no value supplied for price".to_string()),
                    symbol: Err("no value supplied for symbol".to_string()),
                    to_address: Err("no value supplied for to_address".to_string()),
                    to_token_account: Err(
                        "no value supplied for to_token_account".to_string(),
                    ),
                    token_address: Err(
                        "no value supplied for token_address".to_string(),
                    ),
                    tx_hash: Err("no value supplied for tx_hash".to_string()),
                    value: Err("no value supplied for value".to_string()),
                }
            }
        }
        impl TokenTransferItemDto {
            pub fn action<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.action = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for action: {}", e)
                    });
                self
            }
            pub fn amount<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.amount = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for amount: {}", e)
                    });
                self
            }
            pub fn block_number<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<i64>,
                T::Error: ::std::fmt::Display,
            {
                self.block_number = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for block_number: {}", e
                        )
                    });
                self
            }
            pub fn block_time<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<i64>,
                T::Error: ::std::fmt::Display,
            {
                self.block_time = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for block_time: {}", e)
                    });
                self
            }
            pub fn decimals<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<i64>,
                T::Error: ::std::fmt::Display,
            {
                self.decimals = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for decimals: {}", e)
                    });
                self
            }
            pub fn flow<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<super::TokenTransferItemDtoFlow>,
                T::Error: ::std::fmt::Display,
            {
                self.flow = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for flow: {}", e)
                    });
                self
            }
            pub fn from_address<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.from_address = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for from_address: {}", e
                        )
                    });
                self
            }
            pub fn from_token_account<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.from_token_account = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for from_token_account: {}",
                            e
                        )
                    });
                self
            }
            pub fn logo_uri<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.logo_uri = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for logo_uri: {}", e)
                    });
                self
            }
            pub fn name<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.name = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for name: {}", e)
                    });
                self
            }
            pub fn price<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.price = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for price: {}", e)
                    });
                self
            }
            pub fn symbol<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.symbol = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for symbol: {}", e)
                    });
                self
            }
            pub fn to_address<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.to_address = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for to_address: {}", e)
                    });
                self
            }
            pub fn to_token_account<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.to_token_account = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for to_token_account: {}", e
                        )
                    });
                self
            }
            pub fn token_address<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.token_address = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for token_address: {}", e
                        )
                    });
                self
            }
            pub fn tx_hash<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.tx_hash = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for tx_hash: {}", e)
                    });
                self
            }
            pub fn value<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.value = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for value: {}", e)
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<TokenTransferItemDto>
        for super::TokenTransferItemDto {
            type Error = super::error::ConversionError;
            fn try_from(
                value: TokenTransferItemDto,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    action: value.action?,
                    amount: value.amount?,
                    block_number: value.block_number?,
                    block_time: value.block_time?,
                    decimals: value.decimals?,
                    flow: value.flow?,
                    from_address: value.from_address?,
                    from_token_account: value.from_token_account?,
                    logo_uri: value.logo_uri?,
                    name: value.name?,
                    price: value.price?,
                    symbol: value.symbol?,
                    to_address: value.to_address?,
                    to_token_account: value.to_token_account?,
                    token_address: value.token_address?,
                    tx_hash: value.tx_hash?,
                    value: value.value?,
                })
            }
        }
        impl ::std::convert::From<super::TokenTransferItemDto> for TokenTransferItemDto {
            fn from(value: super::TokenTransferItemDto) -> Self {
                Self {
                    action: Ok(value.action),
                    amount: Ok(value.amount),
                    block_number: Ok(value.block_number),
                    block_time: Ok(value.block_time),
                    decimals: Ok(value.decimals),
                    flow: Ok(value.flow),
                    from_address: Ok(value.from_address),
                    from_token_account: Ok(value.from_token_account),
                    logo_uri: Ok(value.logo_uri),
                    name: Ok(value.name),
                    price: Ok(value.price),
                    symbol: Ok(value.symbol),
                    to_address: Ok(value.to_address),
                    to_token_account: Ok(value.to_token_account),
                    token_address: Ok(value.token_address),
                    tx_hash: Ok(value.tx_hash),
                    value: Ok(value.value),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct TokenTransferPage {
            data: ::std::result::Result<
                ::std::vec::Vec<super::TokenTransferItemDto>,
                ::std::string::String,
            >,
            end_cursor: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            has_next: ::std::result::Result<bool, ::std::string::String>,
            has_prev: ::std::result::Result<bool, ::std::string::String>,
            start_cursor: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            total: ::std::result::Result<i64, ::std::string::String>,
        }
        impl ::std::default::Default for TokenTransferPage {
            fn default() -> Self {
                Self {
                    data: Err("no value supplied for data".to_string()),
                    end_cursor: Ok(Default::default()),
                    has_next: Ok(Default::default()),
                    has_prev: Ok(Default::default()),
                    start_cursor: Ok(Default::default()),
                    total: Ok(Default::default()),
                }
            }
        }
        impl TokenTransferPage {
            pub fn data<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::vec::Vec<super::TokenTransferItemDto>>,
                T::Error: ::std::fmt::Display,
            {
                self.data = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for data: {}", e)
                    });
                self
            }
            pub fn end_cursor<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.end_cursor = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for end_cursor: {}", e)
                    });
                self
            }
            pub fn has_next<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<bool>,
                T::Error: ::std::fmt::Display,
            {
                self.has_next = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for has_next: {}", e)
                    });
                self
            }
            pub fn has_prev<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<bool>,
                T::Error: ::std::fmt::Display,
            {
                self.has_prev = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for has_prev: {}", e)
                    });
                self
            }
            pub fn start_cursor<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.start_cursor = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for start_cursor: {}", e
                        )
                    });
                self
            }
            pub fn total<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<i64>,
                T::Error: ::std::fmt::Display,
            {
                self.total = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for total: {}", e)
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<TokenTransferPage> for super::TokenTransferPage {
            type Error = super::error::ConversionError;
            fn try_from(
                value: TokenTransferPage,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    data: value.data?,
                    end_cursor: value.end_cursor?,
                    has_next: value.has_next?,
                    has_prev: value.has_prev?,
                    start_cursor: value.start_cursor?,
                    total: value.total?,
                })
            }
        }
        impl ::std::convert::From<super::TokenTransferPage> for TokenTransferPage {
            fn from(value: super::TokenTransferPage) -> Self {
                Self {
                    data: Ok(value.data),
                    end_cursor: Ok(value.end_cursor),
                    has_next: Ok(value.has_next),
                    has_prev: Ok(value.has_prev),
                    start_cursor: Ok(value.start_cursor),
                    total: Ok(value.total),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct TokenTransferTotalDto {
            total: ::std::result::Result<i64, ::std::string::String>,
        }
        impl ::std::default::Default for TokenTransferTotalDto {
            fn default() -> Self {
                Self {
                    total: Err("no value supplied for total".to_string()),
                }
            }
        }
        impl TokenTransferTotalDto {
            pub fn total<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<i64>,
                T::Error: ::std::fmt::Display,
            {
                self.total = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for total: {}", e)
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<TokenTransferTotalDto>
        for super::TokenTransferTotalDto {
            type Error = super::error::ConversionError;
            fn try_from(
                value: TokenTransferTotalDto,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self { total: value.total? })
            }
        }
        impl ::std::convert::From<super::TokenTransferTotalDto>
        for TokenTransferTotalDto {
            fn from(value: super::TokenTransferTotalDto) -> Self {
                Self { total: Ok(value.total) }
            }
        }
        #[derive(Clone, Debug)]
        pub struct TokensBalancePage {
            data: ::std::result::Result<
                ::std::vec::Vec<super::WalletNetWorthItemDto>,
                ::std::string::String,
            >,
            end_cursor: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            has_next: ::std::result::Result<bool, ::std::string::String>,
            has_prev: ::std::result::Result<bool, ::std::string::String>,
            start_cursor: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            total: ::std::result::Result<i64, ::std::string::String>,
        }
        impl ::std::default::Default for TokensBalancePage {
            fn default() -> Self {
                Self {
                    data: Err("no value supplied for data".to_string()),
                    end_cursor: Ok(Default::default()),
                    has_next: Ok(Default::default()),
                    has_prev: Ok(Default::default()),
                    start_cursor: Ok(Default::default()),
                    total: Ok(Default::default()),
                }
            }
        }
        impl TokensBalancePage {
            pub fn data<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<
                    ::std::vec::Vec<super::WalletNetWorthItemDto>,
                >,
                T::Error: ::std::fmt::Display,
            {
                self.data = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for data: {}", e)
                    });
                self
            }
            pub fn end_cursor<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.end_cursor = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for end_cursor: {}", e)
                    });
                self
            }
            pub fn has_next<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<bool>,
                T::Error: ::std::fmt::Display,
            {
                self.has_next = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for has_next: {}", e)
                    });
                self
            }
            pub fn has_prev<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<bool>,
                T::Error: ::std::fmt::Display,
            {
                self.has_prev = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for has_prev: {}", e)
                    });
                self
            }
            pub fn start_cursor<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.start_cursor = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for start_cursor: {}", e
                        )
                    });
                self
            }
            pub fn total<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<i64>,
                T::Error: ::std::fmt::Display,
            {
                self.total = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for total: {}", e)
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<TokensBalancePage> for super::TokensBalancePage {
            type Error = super::error::ConversionError;
            fn try_from(
                value: TokensBalancePage,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    data: value.data?,
                    end_cursor: value.end_cursor?,
                    has_next: value.has_next?,
                    has_prev: value.has_prev?,
                    start_cursor: value.start_cursor?,
                    total: value.total?,
                })
            }
        }
        impl ::std::convert::From<super::TokensBalancePage> for TokensBalancePage {
            fn from(value: super::TokensBalancePage) -> Self {
                Self {
                    data: Ok(value.data),
                    end_cursor: Ok(value.end_cursor),
                    has_next: Ok(value.has_next),
                    has_prev: Ok(value.has_prev),
                    start_cursor: Ok(value.start_cursor),
                    total: Ok(value.total),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct TopTradersDto {
            buy_amount: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            buy_amount_in_native: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            buy_amount_in_usd: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            buy_count: ::std::result::Result<i64, ::std::string::String>,
            sell_amount: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            sell_amount_in_native: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            sell_amount_in_usd: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            sell_count: ::std::result::Result<i64, ::std::string::String>,
            token_address: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            trade_amount: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            trade_count: ::std::result::Result<i64, ::std::string::String>,
            wallet_address: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for TopTradersDto {
            fn default() -> Self {
                Self {
                    buy_amount: Err("no value supplied for buy_amount".to_string()),
                    buy_amount_in_native: Err(
                        "no value supplied for buy_amount_in_native".to_string(),
                    ),
                    buy_amount_in_usd: Err(
                        "no value supplied for buy_amount_in_usd".to_string(),
                    ),
                    buy_count: Err("no value supplied for buy_count".to_string()),
                    sell_amount: Err("no value supplied for sell_amount".to_string()),
                    sell_amount_in_native: Err(
                        "no value supplied for sell_amount_in_native".to_string(),
                    ),
                    sell_amount_in_usd: Err(
                        "no value supplied for sell_amount_in_usd".to_string(),
                    ),
                    sell_count: Err("no value supplied for sell_count".to_string()),
                    token_address: Err(
                        "no value supplied for token_address".to_string(),
                    ),
                    trade_amount: Err("no value supplied for trade_amount".to_string()),
                    trade_count: Err("no value supplied for trade_count".to_string()),
                    wallet_address: Err(
                        "no value supplied for wallet_address".to_string(),
                    ),
                }
            }
        }
        impl TopTradersDto {
            pub fn buy_amount<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.buy_amount = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for buy_amount: {}", e)
                    });
                self
            }
            pub fn buy_amount_in_native<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.buy_amount_in_native = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for buy_amount_in_native: {}",
                            e
                        )
                    });
                self
            }
            pub fn buy_amount_in_usd<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.buy_amount_in_usd = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for buy_amount_in_usd: {}",
                            e
                        )
                    });
                self
            }
            pub fn buy_count<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<i64>,
                T::Error: ::std::fmt::Display,
            {
                self.buy_count = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for buy_count: {}", e)
                    });
                self
            }
            pub fn sell_amount<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.sell_amount = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for sell_amount: {}", e)
                    });
                self
            }
            pub fn sell_amount_in_native<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.sell_amount_in_native = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for sell_amount_in_native: {}",
                            e
                        )
                    });
                self
            }
            pub fn sell_amount_in_usd<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.sell_amount_in_usd = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for sell_amount_in_usd: {}",
                            e
                        )
                    });
                self
            }
            pub fn sell_count<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<i64>,
                T::Error: ::std::fmt::Display,
            {
                self.sell_count = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for sell_count: {}", e)
                    });
                self
            }
            pub fn token_address<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.token_address = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for token_address: {}", e
                        )
                    });
                self
            }
            pub fn trade_amount<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.trade_amount = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for trade_amount: {}", e
                        )
                    });
                self
            }
            pub fn trade_count<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<i64>,
                T::Error: ::std::fmt::Display,
            {
                self.trade_count = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for trade_count: {}", e)
                    });
                self
            }
            pub fn wallet_address<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.wallet_address = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for wallet_address: {}", e
                        )
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<TopTradersDto> for super::TopTradersDto {
            type Error = super::error::ConversionError;
            fn try_from(
                value: TopTradersDto,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    buy_amount: value.buy_amount?,
                    buy_amount_in_native: value.buy_amount_in_native?,
                    buy_amount_in_usd: value.buy_amount_in_usd?,
                    buy_count: value.buy_count?,
                    sell_amount: value.sell_amount?,
                    sell_amount_in_native: value.sell_amount_in_native?,
                    sell_amount_in_usd: value.sell_amount_in_usd?,
                    sell_count: value.sell_count?,
                    token_address: value.token_address?,
                    trade_amount: value.trade_amount?,
                    trade_count: value.trade_count?,
                    wallet_address: value.wallet_address?,
                })
            }
        }
        impl ::std::convert::From<super::TopTradersDto> for TopTradersDto {
            fn from(value: super::TopTradersDto) -> Self {
                Self {
                    buy_amount: Ok(value.buy_amount),
                    buy_amount_in_native: Ok(value.buy_amount_in_native),
                    buy_amount_in_usd: Ok(value.buy_amount_in_usd),
                    buy_count: Ok(value.buy_count),
                    sell_amount: Ok(value.sell_amount),
                    sell_amount_in_native: Ok(value.sell_amount_in_native),
                    sell_amount_in_usd: Ok(value.sell_amount_in_usd),
                    sell_count: Ok(value.sell_count),
                    token_address: Ok(value.token_address),
                    trade_amount: Ok(value.trade_amount),
                    trade_count: Ok(value.trade_count),
                    wallet_address: Ok(value.wallet_address),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct TopTradersPage {
            data: ::std::result::Result<
                ::std::vec::Vec<super::TopTradersDto>,
                ::std::string::String,
            >,
            end_cursor: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            has_next: ::std::result::Result<bool, ::std::string::String>,
            has_prev: ::std::result::Result<bool, ::std::string::String>,
            start_cursor: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            total: ::std::result::Result<i64, ::std::string::String>,
        }
        impl ::std::default::Default for TopTradersPage {
            fn default() -> Self {
                Self {
                    data: Err("no value supplied for data".to_string()),
                    end_cursor: Ok(Default::default()),
                    has_next: Ok(Default::default()),
                    has_prev: Ok(Default::default()),
                    start_cursor: Ok(Default::default()),
                    total: Ok(Default::default()),
                }
            }
        }
        impl TopTradersPage {
            pub fn data<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::vec::Vec<super::TopTradersDto>>,
                T::Error: ::std::fmt::Display,
            {
                self.data = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for data: {}", e)
                    });
                self
            }
            pub fn end_cursor<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.end_cursor = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for end_cursor: {}", e)
                    });
                self
            }
            pub fn has_next<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<bool>,
                T::Error: ::std::fmt::Display,
            {
                self.has_next = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for has_next: {}", e)
                    });
                self
            }
            pub fn has_prev<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<bool>,
                T::Error: ::std::fmt::Display,
            {
                self.has_prev = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for has_prev: {}", e)
                    });
                self
            }
            pub fn start_cursor<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.start_cursor = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for start_cursor: {}", e
                        )
                    });
                self
            }
            pub fn total<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<i64>,
                T::Error: ::std::fmt::Display,
            {
                self.total = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for total: {}", e)
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<TopTradersPage> for super::TopTradersPage {
            type Error = super::error::ConversionError;
            fn try_from(
                value: TopTradersPage,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    data: value.data?,
                    end_cursor: value.end_cursor?,
                    has_next: value.has_next?,
                    has_prev: value.has_prev?,
                    start_cursor: value.start_cursor?,
                    total: value.total?,
                })
            }
        }
        impl ::std::convert::From<super::TopTradersPage> for TopTradersPage {
            fn from(value: super::TopTradersPage) -> Self {
                Self {
                    data: Ok(value.data),
                    end_cursor: Ok(value.end_cursor),
                    has_next: Ok(value.has_next),
                    has_prev: Ok(value.has_prev),
                    start_cursor: Ok(value.start_cursor),
                    total: Ok(value.total),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct TradeDetailDto {
            account_owner_address: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            block_height: ::std::result::Result<i64, ::std::string::String>,
            block_timestamp: ::std::result::Result<i64, ::std::string::String>,
            chain: ::std::result::Result<::std::string::String, ::std::string::String>,
            dex_image: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            dex_program_address: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            dex_protocol_family: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            pool_address: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            side_token_address: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            side_token_amount: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            side_token_amount_in_native: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            side_token_amount_in_usd: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            side_token_image_url: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            side_token_name: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            side_token_price_in_native: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            side_token_price_in_usd: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            side_token_symbol: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            status: ::std::result::Result<::std::string::String, ::std::string::String>,
            token_address: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            token_amount: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            token_amount_in_native: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            token_amount_in_usd: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            token_image_url: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            token_name: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            token_price_in_native: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            token_price_in_usd: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            token_symbol: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            transaction_signature: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            type_: ::std::result::Result<::std::string::String, ::std::string::String>,
        }
        impl ::std::default::Default for TradeDetailDto {
            fn default() -> Self {
                Self {
                    account_owner_address: Err(
                        "no value supplied for account_owner_address".to_string(),
                    ),
                    block_height: Err("no value supplied for block_height".to_string()),
                    block_timestamp: Err(
                        "no value supplied for block_timestamp".to_string(),
                    ),
                    chain: Err("no value supplied for chain".to_string()),
                    dex_image: Err("no value supplied for dex_image".to_string()),
                    dex_program_address: Err(
                        "no value supplied for dex_program_address".to_string(),
                    ),
                    dex_protocol_family: Err(
                        "no value supplied for dex_protocol_family".to_string(),
                    ),
                    pool_address: Err("no value supplied for pool_address".to_string()),
                    side_token_address: Err(
                        "no value supplied for side_token_address".to_string(),
                    ),
                    side_token_amount: Err(
                        "no value supplied for side_token_amount".to_string(),
                    ),
                    side_token_amount_in_native: Err(
                        "no value supplied for side_token_amount_in_native".to_string(),
                    ),
                    side_token_amount_in_usd: Err(
                        "no value supplied for side_token_amount_in_usd".to_string(),
                    ),
                    side_token_image_url: Err(
                        "no value supplied for side_token_image_url".to_string(),
                    ),
                    side_token_name: Err(
                        "no value supplied for side_token_name".to_string(),
                    ),
                    side_token_price_in_native: Err(
                        "no value supplied for side_token_price_in_native".to_string(),
                    ),
                    side_token_price_in_usd: Err(
                        "no value supplied for side_token_price_in_usd".to_string(),
                    ),
                    side_token_symbol: Err(
                        "no value supplied for side_token_symbol".to_string(),
                    ),
                    status: Err("no value supplied for status".to_string()),
                    token_address: Err(
                        "no value supplied for token_address".to_string(),
                    ),
                    token_amount: Err("no value supplied for token_amount".to_string()),
                    token_amount_in_native: Err(
                        "no value supplied for token_amount_in_native".to_string(),
                    ),
                    token_amount_in_usd: Err(
                        "no value supplied for token_amount_in_usd".to_string(),
                    ),
                    token_image_url: Err(
                        "no value supplied for token_image_url".to_string(),
                    ),
                    token_name: Err("no value supplied for token_name".to_string()),
                    token_price_in_native: Err(
                        "no value supplied for token_price_in_native".to_string(),
                    ),
                    token_price_in_usd: Err(
                        "no value supplied for token_price_in_usd".to_string(),
                    ),
                    token_symbol: Err("no value supplied for token_symbol".to_string()),
                    transaction_signature: Err(
                        "no value supplied for transaction_signature".to_string(),
                    ),
                    type_: Err("no value supplied for type_".to_string()),
                }
            }
        }
        impl TradeDetailDto {
            pub fn account_owner_address<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.account_owner_address = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for account_owner_address: {}",
                            e
                        )
                    });
                self
            }
            pub fn block_height<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<i64>,
                T::Error: ::std::fmt::Display,
            {
                self.block_height = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for block_height: {}", e
                        )
                    });
                self
            }
            pub fn block_timestamp<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<i64>,
                T::Error: ::std::fmt::Display,
            {
                self.block_timestamp = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for block_timestamp: {}", e
                        )
                    });
                self
            }
            pub fn chain<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.chain = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for chain: {}", e)
                    });
                self
            }
            pub fn dex_image<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.dex_image = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for dex_image: {}", e)
                    });
                self
            }
            pub fn dex_program_address<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.dex_program_address = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for dex_program_address: {}",
                            e
                        )
                    });
                self
            }
            pub fn dex_protocol_family<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.dex_protocol_family = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for dex_protocol_family: {}",
                            e
                        )
                    });
                self
            }
            pub fn pool_address<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.pool_address = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for pool_address: {}", e
                        )
                    });
                self
            }
            pub fn side_token_address<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.side_token_address = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for side_token_address: {}",
                            e
                        )
                    });
                self
            }
            pub fn side_token_amount<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.side_token_amount = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for side_token_amount: {}",
                            e
                        )
                    });
                self
            }
            pub fn side_token_amount_in_native<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.side_token_amount_in_native = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for side_token_amount_in_native: {}",
                            e
                        )
                    });
                self
            }
            pub fn side_token_amount_in_usd<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.side_token_amount_in_usd = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for side_token_amount_in_usd: {}",
                            e
                        )
                    });
                self
            }
            pub fn side_token_image_url<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.side_token_image_url = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for side_token_image_url: {}",
                            e
                        )
                    });
                self
            }
            pub fn side_token_name<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.side_token_name = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for side_token_name: {}", e
                        )
                    });
                self
            }
            pub fn side_token_price_in_native<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.side_token_price_in_native = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for side_token_price_in_native: {}",
                            e
                        )
                    });
                self
            }
            pub fn side_token_price_in_usd<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.side_token_price_in_usd = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for side_token_price_in_usd: {}",
                            e
                        )
                    });
                self
            }
            pub fn side_token_symbol<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.side_token_symbol = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for side_token_symbol: {}",
                            e
                        )
                    });
                self
            }
            pub fn status<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.status = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for status: {}", e)
                    });
                self
            }
            pub fn token_address<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.token_address = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for token_address: {}", e
                        )
                    });
                self
            }
            pub fn token_amount<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.token_amount = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for token_amount: {}", e
                        )
                    });
                self
            }
            pub fn token_amount_in_native<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.token_amount_in_native = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for token_amount_in_native: {}",
                            e
                        )
                    });
                self
            }
            pub fn token_amount_in_usd<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.token_amount_in_usd = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for token_amount_in_usd: {}",
                            e
                        )
                    });
                self
            }
            pub fn token_image_url<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.token_image_url = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for token_image_url: {}", e
                        )
                    });
                self
            }
            pub fn token_name<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.token_name = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for token_name: {}", e)
                    });
                self
            }
            pub fn token_price_in_native<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.token_price_in_native = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for token_price_in_native: {}",
                            e
                        )
                    });
                self
            }
            pub fn token_price_in_usd<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.token_price_in_usd = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for token_price_in_usd: {}",
                            e
                        )
                    });
                self
            }
            pub fn token_symbol<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.token_symbol = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for token_symbol: {}", e
                        )
                    });
                self
            }
            pub fn transaction_signature<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.transaction_signature = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for transaction_signature: {}",
                            e
                        )
                    });
                self
            }
            pub fn type_<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.type_ = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for type_: {}", e)
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<TradeDetailDto> for super::TradeDetailDto {
            type Error = super::error::ConversionError;
            fn try_from(
                value: TradeDetailDto,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    account_owner_address: value.account_owner_address?,
                    block_height: value.block_height?,
                    block_timestamp: value.block_timestamp?,
                    chain: value.chain?,
                    dex_image: value.dex_image?,
                    dex_program_address: value.dex_program_address?,
                    dex_protocol_family: value.dex_protocol_family?,
                    pool_address: value.pool_address?,
                    side_token_address: value.side_token_address?,
                    side_token_amount: value.side_token_amount?,
                    side_token_amount_in_native: value.side_token_amount_in_native?,
                    side_token_amount_in_usd: value.side_token_amount_in_usd?,
                    side_token_image_url: value.side_token_image_url?,
                    side_token_name: value.side_token_name?,
                    side_token_price_in_native: value.side_token_price_in_native?,
                    side_token_price_in_usd: value.side_token_price_in_usd?,
                    side_token_symbol: value.side_token_symbol?,
                    status: value.status?,
                    token_address: value.token_address?,
                    token_amount: value.token_amount?,
                    token_amount_in_native: value.token_amount_in_native?,
                    token_amount_in_usd: value.token_amount_in_usd?,
                    token_image_url: value.token_image_url?,
                    token_name: value.token_name?,
                    token_price_in_native: value.token_price_in_native?,
                    token_price_in_usd: value.token_price_in_usd?,
                    token_symbol: value.token_symbol?,
                    transaction_signature: value.transaction_signature?,
                    type_: value.type_?,
                })
            }
        }
        impl ::std::convert::From<super::TradeDetailDto> for TradeDetailDto {
            fn from(value: super::TradeDetailDto) -> Self {
                Self {
                    account_owner_address: Ok(value.account_owner_address),
                    block_height: Ok(value.block_height),
                    block_timestamp: Ok(value.block_timestamp),
                    chain: Ok(value.chain),
                    dex_image: Ok(value.dex_image),
                    dex_program_address: Ok(value.dex_program_address),
                    dex_protocol_family: Ok(value.dex_protocol_family),
                    pool_address: Ok(value.pool_address),
                    side_token_address: Ok(value.side_token_address),
                    side_token_amount: Ok(value.side_token_amount),
                    side_token_amount_in_native: Ok(value.side_token_amount_in_native),
                    side_token_amount_in_usd: Ok(value.side_token_amount_in_usd),
                    side_token_image_url: Ok(value.side_token_image_url),
                    side_token_name: Ok(value.side_token_name),
                    side_token_price_in_native: Ok(value.side_token_price_in_native),
                    side_token_price_in_usd: Ok(value.side_token_price_in_usd),
                    side_token_symbol: Ok(value.side_token_symbol),
                    status: Ok(value.status),
                    token_address: Ok(value.token_address),
                    token_amount: Ok(value.token_amount),
                    token_amount_in_native: Ok(value.token_amount_in_native),
                    token_amount_in_usd: Ok(value.token_amount_in_usd),
                    token_image_url: Ok(value.token_image_url),
                    token_name: Ok(value.token_name),
                    token_price_in_native: Ok(value.token_price_in_native),
                    token_price_in_usd: Ok(value.token_price_in_usd),
                    token_symbol: Ok(value.token_symbol),
                    transaction_signature: Ok(value.transaction_signature),
                    type_: Ok(value.type_),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct TradeEvent {
            amount_in_usd: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            base_amount: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            buy_cost_usd: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            event: ::std::result::Result<super::TradeType, ::std::string::String>,
            id: ::std::result::Result<::std::string::String, ::std::string::String>,
            maker: ::std::result::Result<::std::string::String, ::std::string::String>,
            price_in_usd: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            quote_address: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            quote_amount: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            quote_symbol: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            timestamp: ::std::result::Result<i64, ::std::string::String>,
            token_address: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            tx_hash: ::std::result::Result<::std::string::String, ::std::string::String>,
        }
        impl ::std::default::Default for TradeEvent {
            fn default() -> Self {
                Self {
                    amount_in_usd: Err(
                        "no value supplied for amount_in_usd".to_string(),
                    ),
                    base_amount: Err("no value supplied for base_amount".to_string()),
                    buy_cost_usd: Err("no value supplied for buy_cost_usd".to_string()),
                    event: Err("no value supplied for event".to_string()),
                    id: Err("no value supplied for id".to_string()),
                    maker: Err("no value supplied for maker".to_string()),
                    price_in_usd: Err("no value supplied for price_in_usd".to_string()),
                    quote_address: Err(
                        "no value supplied for quote_address".to_string(),
                    ),
                    quote_amount: Err("no value supplied for quote_amount".to_string()),
                    quote_symbol: Err("no value supplied for quote_symbol".to_string()),
                    timestamp: Err("no value supplied for timestamp".to_string()),
                    token_address: Err(
                        "no value supplied for token_address".to_string(),
                    ),
                    tx_hash: Err("no value supplied for tx_hash".to_string()),
                }
            }
        }
        impl TradeEvent {
            pub fn amount_in_usd<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.amount_in_usd = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for amount_in_usd: {}", e
                        )
                    });
                self
            }
            pub fn base_amount<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.base_amount = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for base_amount: {}", e)
                    });
                self
            }
            pub fn buy_cost_usd<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.buy_cost_usd = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for buy_cost_usd: {}", e
                        )
                    });
                self
            }
            pub fn event<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<super::TradeType>,
                T::Error: ::std::fmt::Display,
            {
                self.event = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for event: {}", e)
                    });
                self
            }
            pub fn id<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.id = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for id: {}", e)
                    });
                self
            }
            pub fn maker<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.maker = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for maker: {}", e)
                    });
                self
            }
            pub fn price_in_usd<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.price_in_usd = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for price_in_usd: {}", e
                        )
                    });
                self
            }
            pub fn quote_address<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.quote_address = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for quote_address: {}", e
                        )
                    });
                self
            }
            pub fn quote_amount<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.quote_amount = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for quote_amount: {}", e
                        )
                    });
                self
            }
            pub fn quote_symbol<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.quote_symbol = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for quote_symbol: {}", e
                        )
                    });
                self
            }
            pub fn timestamp<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<i64>,
                T::Error: ::std::fmt::Display,
            {
                self.timestamp = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for timestamp: {}", e)
                    });
                self
            }
            pub fn token_address<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.token_address = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for token_address: {}", e
                        )
                    });
                self
            }
            pub fn tx_hash<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.tx_hash = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for tx_hash: {}", e)
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<TradeEvent> for super::TradeEvent {
            type Error = super::error::ConversionError;
            fn try_from(
                value: TradeEvent,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    amount_in_usd: value.amount_in_usd?,
                    base_amount: value.base_amount?,
                    buy_cost_usd: value.buy_cost_usd?,
                    event: value.event?,
                    id: value.id?,
                    maker: value.maker?,
                    price_in_usd: value.price_in_usd?,
                    quote_address: value.quote_address?,
                    quote_amount: value.quote_amount?,
                    quote_symbol: value.quote_symbol?,
                    timestamp: value.timestamp?,
                    token_address: value.token_address?,
                    tx_hash: value.tx_hash?,
                })
            }
        }
        impl ::std::convert::From<super::TradeEvent> for TradeEvent {
            fn from(value: super::TradeEvent) -> Self {
                Self {
                    amount_in_usd: Ok(value.amount_in_usd),
                    base_amount: Ok(value.base_amount),
                    buy_cost_usd: Ok(value.buy_cost_usd),
                    event: Ok(value.event),
                    id: Ok(value.id),
                    maker: Ok(value.maker),
                    price_in_usd: Ok(value.price_in_usd),
                    quote_address: Ok(value.quote_address),
                    quote_amount: Ok(value.quote_amount),
                    quote_symbol: Ok(value.quote_symbol),
                    timestamp: Ok(value.timestamp),
                    token_address: Ok(value.token_address),
                    tx_hash: Ok(value.tx_hash),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct TradePage {
            data: ::std::result::Result<
                ::std::vec::Vec<super::TradeDetailDto>,
                ::std::string::String,
            >,
            end_cursor: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            has_next: ::std::result::Result<bool, ::std::string::String>,
            has_prev: ::std::result::Result<bool, ::std::string::String>,
            start_cursor: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            total: ::std::result::Result<i64, ::std::string::String>,
        }
        impl ::std::default::Default for TradePage {
            fn default() -> Self {
                Self {
                    data: Err("no value supplied for data".to_string()),
                    end_cursor: Ok(Default::default()),
                    has_next: Ok(Default::default()),
                    has_prev: Ok(Default::default()),
                    start_cursor: Ok(Default::default()),
                    total: Ok(Default::default()),
                }
            }
        }
        impl TradePage {
            pub fn data<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::vec::Vec<super::TradeDetailDto>>,
                T::Error: ::std::fmt::Display,
            {
                self.data = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for data: {}", e)
                    });
                self
            }
            pub fn end_cursor<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.end_cursor = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for end_cursor: {}", e)
                    });
                self
            }
            pub fn has_next<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<bool>,
                T::Error: ::std::fmt::Display,
            {
                self.has_next = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for has_next: {}", e)
                    });
                self
            }
            pub fn has_prev<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<bool>,
                T::Error: ::std::fmt::Display,
            {
                self.has_prev = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for has_prev: {}", e)
                    });
                self
            }
            pub fn start_cursor<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.start_cursor = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for start_cursor: {}", e
                        )
                    });
                self
            }
            pub fn total<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<i64>,
                T::Error: ::std::fmt::Display,
            {
                self.total = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for total: {}", e)
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<TradePage> for super::TradePage {
            type Error = super::error::ConversionError;
            fn try_from(
                value: TradePage,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    data: value.data?,
                    end_cursor: value.end_cursor?,
                    has_next: value.has_next?,
                    has_prev: value.has_prev?,
                    start_cursor: value.start_cursor?,
                    total: value.total?,
                })
            }
        }
        impl ::std::convert::From<super::TradePage> for TradePage {
            fn from(value: super::TradePage) -> Self {
                Self {
                    data: Ok(value.data),
                    end_cursor: Ok(value.end_cursor),
                    has_next: Ok(value.has_next),
                    has_prev: Ok(value.has_prev),
                    start_cursor: Ok(value.start_cursor),
                    total: Ok(value.total),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct TraderGainersLosersItemDto {
            address: ::std::result::Result<::std::string::String, ::std::string::String>,
            chain: ::std::result::Result<super::ChainSymbol, ::std::string::String>,
            pnl: ::std::result::Result<::std::string::String, ::std::string::String>,
            trade_count: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            volume: ::std::result::Result<::std::string::String, ::std::string::String>,
        }
        impl ::std::default::Default for TraderGainersLosersItemDto {
            fn default() -> Self {
                Self {
                    address: Err("no value supplied for address".to_string()),
                    chain: Err("no value supplied for chain".to_string()),
                    pnl: Err("no value supplied for pnl".to_string()),
                    trade_count: Err("no value supplied for trade_count".to_string()),
                    volume: Err("no value supplied for volume".to_string()),
                }
            }
        }
        impl TraderGainersLosersItemDto {
            pub fn address<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.address = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for address: {}", e)
                    });
                self
            }
            pub fn chain<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<super::ChainSymbol>,
                T::Error: ::std::fmt::Display,
            {
                self.chain = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for chain: {}", e)
                    });
                self
            }
            pub fn pnl<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.pnl = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for pnl: {}", e)
                    });
                self
            }
            pub fn trade_count<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.trade_count = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for trade_count: {}", e)
                    });
                self
            }
            pub fn volume<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.volume = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for volume: {}", e)
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<TraderGainersLosersItemDto>
        for super::TraderGainersLosersItemDto {
            type Error = super::error::ConversionError;
            fn try_from(
                value: TraderGainersLosersItemDto,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    address: value.address?,
                    chain: value.chain?,
                    pnl: value.pnl?,
                    trade_count: value.trade_count?,
                    volume: value.volume?,
                })
            }
        }
        impl ::std::convert::From<super::TraderGainersLosersItemDto>
        for TraderGainersLosersItemDto {
            fn from(value: super::TraderGainersLosersItemDto) -> Self {
                Self {
                    address: Ok(value.address),
                    chain: Ok(value.chain),
                    pnl: Ok(value.pnl),
                    trade_count: Ok(value.trade_count),
                    volume: Ok(value.volume),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct TraderGainersLosersPage {
            data: ::std::result::Result<
                ::std::vec::Vec<super::TraderGainersLosersItemDto>,
                ::std::string::String,
            >,
            end_cursor: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            has_next: ::std::result::Result<bool, ::std::string::String>,
            has_prev: ::std::result::Result<bool, ::std::string::String>,
            start_cursor: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            total: ::std::result::Result<i64, ::std::string::String>,
        }
        impl ::std::default::Default for TraderGainersLosersPage {
            fn default() -> Self {
                Self {
                    data: Err("no value supplied for data".to_string()),
                    end_cursor: Ok(Default::default()),
                    has_next: Ok(Default::default()),
                    has_prev: Ok(Default::default()),
                    start_cursor: Ok(Default::default()),
                    total: Ok(Default::default()),
                }
            }
        }
        impl TraderGainersLosersPage {
            pub fn data<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<
                    ::std::vec::Vec<super::TraderGainersLosersItemDto>,
                >,
                T::Error: ::std::fmt::Display,
            {
                self.data = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for data: {}", e)
                    });
                self
            }
            pub fn end_cursor<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.end_cursor = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for end_cursor: {}", e)
                    });
                self
            }
            pub fn has_next<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<bool>,
                T::Error: ::std::fmt::Display,
            {
                self.has_next = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for has_next: {}", e)
                    });
                self
            }
            pub fn has_prev<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<bool>,
                T::Error: ::std::fmt::Display,
            {
                self.has_prev = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for has_prev: {}", e)
                    });
                self
            }
            pub fn start_cursor<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.start_cursor = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for start_cursor: {}", e
                        )
                    });
                self
            }
            pub fn total<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<i64>,
                T::Error: ::std::fmt::Display,
            {
                self.total = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for total: {}", e)
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<TraderGainersLosersPage>
        for super::TraderGainersLosersPage {
            type Error = super::error::ConversionError;
            fn try_from(
                value: TraderGainersLosersPage,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    data: value.data?,
                    end_cursor: value.end_cursor?,
                    has_next: value.has_next?,
                    has_prev: value.has_prev?,
                    start_cursor: value.start_cursor?,
                    total: value.total?,
                })
            }
        }
        impl ::std::convert::From<super::TraderGainersLosersPage>
        for TraderGainersLosersPage {
            fn from(value: super::TraderGainersLosersPage) -> Self {
                Self {
                    data: Ok(value.data),
                    end_cursor: Ok(value.end_cursor),
                    has_next: Ok(value.has_next),
                    has_prev: Ok(value.has_prev),
                    start_cursor: Ok(value.start_cursor),
                    total: Ok(value.total),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct TransactionHistoryItemDto {
            block_number: ::std::result::Result<i64, ::std::string::String>,
            block_time: ::std::result::Result<i64, ::std::string::String>,
            dapp_program: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            decimals: ::std::result::Result<i64, ::std::string::String>,
            fee: ::std::result::Result<::std::string::String, ::std::string::String>,
            from: ::std::result::Result<::std::string::String, ::std::string::String>,
            from_token_account: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            from_user_account: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            logo_uri: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            main_action: ::std::result::Result<
                super::TransactionHistoryItemDtoMainAction,
                ::std::string::String,
            >,
            name: ::std::result::Result<::std::string::String, ::std::string::String>,
            outer_dapp_program: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            status: ::std::result::Result<
                super::TransactionHistoryItemDtoStatus,
                ::std::string::String,
            >,
            symbol: ::std::result::Result<::std::string::String, ::std::string::String>,
            to: ::std::result::Result<::std::string::String, ::std::string::String>,
            to_token_account: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            to_user_account: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            token_address: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            token_amount: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            token_amount_in_usd: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            token_price_in_usd: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            tx_hash: ::std::result::Result<::std::string::String, ::std::string::String>,
        }
        impl ::std::default::Default for TransactionHistoryItemDto {
            fn default() -> Self {
                Self {
                    block_number: Err("no value supplied for block_number".to_string()),
                    block_time: Err("no value supplied for block_time".to_string()),
                    dapp_program: Err("no value supplied for dapp_program".to_string()),
                    decimals: Err("no value supplied for decimals".to_string()),
                    fee: Err("no value supplied for fee".to_string()),
                    from: Err("no value supplied for from".to_string()),
                    from_token_account: Err(
                        "no value supplied for from_token_account".to_string(),
                    ),
                    from_user_account: Err(
                        "no value supplied for from_user_account".to_string(),
                    ),
                    logo_uri: Ok(Default::default()),
                    main_action: Err("no value supplied for main_action".to_string()),
                    name: Err("no value supplied for name".to_string()),
                    outer_dapp_program: Err(
                        "no value supplied for outer_dapp_program".to_string(),
                    ),
                    status: Err("no value supplied for status".to_string()),
                    symbol: Err("no value supplied for symbol".to_string()),
                    to: Err("no value supplied for to".to_string()),
                    to_token_account: Err(
                        "no value supplied for to_token_account".to_string(),
                    ),
                    to_user_account: Err(
                        "no value supplied for to_user_account".to_string(),
                    ),
                    token_address: Err(
                        "no value supplied for token_address".to_string(),
                    ),
                    token_amount: Err("no value supplied for token_amount".to_string()),
                    token_amount_in_usd: Err(
                        "no value supplied for token_amount_in_usd".to_string(),
                    ),
                    token_price_in_usd: Err(
                        "no value supplied for token_price_in_usd".to_string(),
                    ),
                    tx_hash: Err("no value supplied for tx_hash".to_string()),
                }
            }
        }
        impl TransactionHistoryItemDto {
            pub fn block_number<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<i64>,
                T::Error: ::std::fmt::Display,
            {
                self.block_number = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for block_number: {}", e
                        )
                    });
                self
            }
            pub fn block_time<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<i64>,
                T::Error: ::std::fmt::Display,
            {
                self.block_time = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for block_time: {}", e)
                    });
                self
            }
            pub fn dapp_program<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.dapp_program = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for dapp_program: {}", e
                        )
                    });
                self
            }
            pub fn decimals<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<i64>,
                T::Error: ::std::fmt::Display,
            {
                self.decimals = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for decimals: {}", e)
                    });
                self
            }
            pub fn fee<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.fee = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for fee: {}", e)
                    });
                self
            }
            pub fn from<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.from = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for from: {}", e)
                    });
                self
            }
            pub fn from_token_account<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.from_token_account = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for from_token_account: {}",
                            e
                        )
                    });
                self
            }
            pub fn from_user_account<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.from_user_account = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for from_user_account: {}",
                            e
                        )
                    });
                self
            }
            pub fn logo_uri<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.logo_uri = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for logo_uri: {}", e)
                    });
                self
            }
            pub fn main_action<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<super::TransactionHistoryItemDtoMainAction>,
                T::Error: ::std::fmt::Display,
            {
                self.main_action = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for main_action: {}", e)
                    });
                self
            }
            pub fn name<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.name = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for name: {}", e)
                    });
                self
            }
            pub fn outer_dapp_program<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.outer_dapp_program = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for outer_dapp_program: {}",
                            e
                        )
                    });
                self
            }
            pub fn status<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<super::TransactionHistoryItemDtoStatus>,
                T::Error: ::std::fmt::Display,
            {
                self.status = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for status: {}", e)
                    });
                self
            }
            pub fn symbol<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.symbol = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for symbol: {}", e)
                    });
                self
            }
            pub fn to<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.to = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for to: {}", e)
                    });
                self
            }
            pub fn to_token_account<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.to_token_account = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for to_token_account: {}", e
                        )
                    });
                self
            }
            pub fn to_user_account<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.to_user_account = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for to_user_account: {}", e
                        )
                    });
                self
            }
            pub fn token_address<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.token_address = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for token_address: {}", e
                        )
                    });
                self
            }
            pub fn token_amount<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.token_amount = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for token_amount: {}", e
                        )
                    });
                self
            }
            pub fn token_amount_in_usd<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.token_amount_in_usd = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for token_amount_in_usd: {}",
                            e
                        )
                    });
                self
            }
            pub fn token_price_in_usd<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.token_price_in_usd = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for token_price_in_usd: {}",
                            e
                        )
                    });
                self
            }
            pub fn tx_hash<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.tx_hash = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for tx_hash: {}", e)
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<TransactionHistoryItemDto>
        for super::TransactionHistoryItemDto {
            type Error = super::error::ConversionError;
            fn try_from(
                value: TransactionHistoryItemDto,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    block_number: value.block_number?,
                    block_time: value.block_time?,
                    dapp_program: value.dapp_program?,
                    decimals: value.decimals?,
                    fee: value.fee?,
                    from: value.from?,
                    from_token_account: value.from_token_account?,
                    from_user_account: value.from_user_account?,
                    logo_uri: value.logo_uri?,
                    main_action: value.main_action?,
                    name: value.name?,
                    outer_dapp_program: value.outer_dapp_program?,
                    status: value.status?,
                    symbol: value.symbol?,
                    to: value.to?,
                    to_token_account: value.to_token_account?,
                    to_user_account: value.to_user_account?,
                    token_address: value.token_address?,
                    token_amount: value.token_amount?,
                    token_amount_in_usd: value.token_amount_in_usd?,
                    token_price_in_usd: value.token_price_in_usd?,
                    tx_hash: value.tx_hash?,
                })
            }
        }
        impl ::std::convert::From<super::TransactionHistoryItemDto>
        for TransactionHistoryItemDto {
            fn from(value: super::TransactionHistoryItemDto) -> Self {
                Self {
                    block_number: Ok(value.block_number),
                    block_time: Ok(value.block_time),
                    dapp_program: Ok(value.dapp_program),
                    decimals: Ok(value.decimals),
                    fee: Ok(value.fee),
                    from: Ok(value.from),
                    from_token_account: Ok(value.from_token_account),
                    from_user_account: Ok(value.from_user_account),
                    logo_uri: Ok(value.logo_uri),
                    main_action: Ok(value.main_action),
                    name: Ok(value.name),
                    outer_dapp_program: Ok(value.outer_dapp_program),
                    status: Ok(value.status),
                    symbol: Ok(value.symbol),
                    to: Ok(value.to),
                    to_token_account: Ok(value.to_token_account),
                    to_user_account: Ok(value.to_user_account),
                    token_address: Ok(value.token_address),
                    token_amount: Ok(value.token_amount),
                    token_amount_in_usd: Ok(value.token_amount_in_usd),
                    token_price_in_usd: Ok(value.token_price_in_usd),
                    tx_hash: Ok(value.tx_hash),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct TransactionHistoryPage {
            data: ::std::result::Result<
                ::std::vec::Vec<super::TransactionHistoryItemDto>,
                ::std::string::String,
            >,
            end_cursor: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            has_next: ::std::result::Result<bool, ::std::string::String>,
            has_prev: ::std::result::Result<bool, ::std::string::String>,
            start_cursor: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            total: ::std::result::Result<i64, ::std::string::String>,
        }
        impl ::std::default::Default for TransactionHistoryPage {
            fn default() -> Self {
                Self {
                    data: Err("no value supplied for data".to_string()),
                    end_cursor: Ok(Default::default()),
                    has_next: Ok(Default::default()),
                    has_prev: Ok(Default::default()),
                    start_cursor: Ok(Default::default()),
                    total: Ok(Default::default()),
                }
            }
        }
        impl TransactionHistoryPage {
            pub fn data<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<
                    ::std::vec::Vec<super::TransactionHistoryItemDto>,
                >,
                T::Error: ::std::fmt::Display,
            {
                self.data = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for data: {}", e)
                    });
                self
            }
            pub fn end_cursor<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.end_cursor = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for end_cursor: {}", e)
                    });
                self
            }
            pub fn has_next<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<bool>,
                T::Error: ::std::fmt::Display,
            {
                self.has_next = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for has_next: {}", e)
                    });
                self
            }
            pub fn has_prev<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<bool>,
                T::Error: ::std::fmt::Display,
            {
                self.has_prev = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for has_prev: {}", e)
                    });
                self
            }
            pub fn start_cursor<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.start_cursor = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for start_cursor: {}", e
                        )
                    });
                self
            }
            pub fn total<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<i64>,
                T::Error: ::std::fmt::Display,
            {
                self.total = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for total: {}", e)
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<TransactionHistoryPage>
        for super::TransactionHistoryPage {
            type Error = super::error::ConversionError;
            fn try_from(
                value: TransactionHistoryPage,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    data: value.data?,
                    end_cursor: value.end_cursor?,
                    has_next: value.has_next?,
                    has_prev: value.has_prev?,
                    start_cursor: value.start_cursor?,
                    total: value.total?,
                })
            }
        }
        impl ::std::convert::From<super::TransactionHistoryPage>
        for TransactionHistoryPage {
            fn from(value: super::TransactionHistoryPage) -> Self {
                Self {
                    data: Ok(value.data),
                    end_cursor: Ok(value.end_cursor),
                    has_next: Ok(value.has_next),
                    has_prev: Ok(value.has_prev),
                    start_cursor: Ok(value.start_cursor),
                    total: Ok(value.total),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct TransferAlertsResponseDto {
            alerts: ::std::result::Result<
                ::std::vec::Vec<super::AlertDetail>,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for TransferAlertsResponseDto {
            fn default() -> Self {
                Self {
                    alerts: Err("no value supplied for alerts".to_string()),
                }
            }
        }
        impl TransferAlertsResponseDto {
            pub fn alerts<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::vec::Vec<super::AlertDetail>>,
                T::Error: ::std::fmt::Display,
            {
                self.alerts = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for alerts: {}", e)
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<TransferAlertsResponseDto>
        for super::TransferAlertsResponseDto {
            type Error = super::error::ConversionError;
            fn try_from(
                value: TransferAlertsResponseDto,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self { alerts: value.alerts? })
            }
        }
        impl ::std::convert::From<super::TransferAlertsResponseDto>
        for TransferAlertsResponseDto {
            fn from(value: super::TransferAlertsResponseDto) -> Self {
                Self { alerts: Ok(value.alerts) }
            }
        }
        #[derive(Clone, Debug)]
        pub struct TransferBaseResponseDto {
            asset: ::std::result::Result<::std::string::String, ::std::string::String>,
            asset_amount: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            asset_id: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            external_id: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            idx: ::std::result::Result<
                ::std::option::Option<i64>,
                ::std::string::String,
            >,
            memo: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            network: ::std::result::Result<::std::string::String, ::std::string::String>,
            output_address: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            timestamp: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            transfer_reference: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            tx: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            updated_at: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            usd_amount: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for TransferBaseResponseDto {
            fn default() -> Self {
                Self {
                    asset: Err("no value supplied for asset".to_string()),
                    asset_amount: Err("no value supplied for asset_amount".to_string()),
                    asset_id: Err("no value supplied for asset_id".to_string()),
                    external_id: Err("no value supplied for external_id".to_string()),
                    idx: Err("no value supplied for idx".to_string()),
                    memo: Err("no value supplied for memo".to_string()),
                    network: Err("no value supplied for network".to_string()),
                    output_address: Err(
                        "no value supplied for output_address".to_string(),
                    ),
                    timestamp: Err("no value supplied for timestamp".to_string()),
                    transfer_reference: Err(
                        "no value supplied for transfer_reference".to_string(),
                    ),
                    tx: Err("no value supplied for tx".to_string()),
                    updated_at: Err("no value supplied for updated_at".to_string()),
                    usd_amount: Err("no value supplied for usd_amount".to_string()),
                }
            }
        }
        impl TransferBaseResponseDto {
            pub fn asset<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.asset = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for asset: {}", e)
                    });
                self
            }
            pub fn asset_amount<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.asset_amount = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for asset_amount: {}", e
                        )
                    });
                self
            }
            pub fn asset_id<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.asset_id = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for asset_id: {}", e)
                    });
                self
            }
            pub fn external_id<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.external_id = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for external_id: {}", e)
                    });
                self
            }
            pub fn idx<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<i64>>,
                T::Error: ::std::fmt::Display,
            {
                self.idx = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for idx: {}", e)
                    });
                self
            }
            pub fn memo<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.memo = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for memo: {}", e)
                    });
                self
            }
            pub fn network<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.network = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for network: {}", e)
                    });
                self
            }
            pub fn output_address<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.output_address = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for output_address: {}", e
                        )
                    });
                self
            }
            pub fn timestamp<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.timestamp = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for timestamp: {}", e)
                    });
                self
            }
            pub fn transfer_reference<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.transfer_reference = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for transfer_reference: {}",
                            e
                        )
                    });
                self
            }
            pub fn tx<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.tx = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for tx: {}", e)
                    });
                self
            }
            pub fn updated_at<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.updated_at = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for updated_at: {}", e)
                    });
                self
            }
            pub fn usd_amount<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.usd_amount = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for usd_amount: {}", e)
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<TransferBaseResponseDto>
        for super::TransferBaseResponseDto {
            type Error = super::error::ConversionError;
            fn try_from(
                value: TransferBaseResponseDto,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    asset: value.asset?,
                    asset_amount: value.asset_amount?,
                    asset_id: value.asset_id?,
                    external_id: value.external_id?,
                    idx: value.idx?,
                    memo: value.memo?,
                    network: value.network?,
                    output_address: value.output_address?,
                    timestamp: value.timestamp?,
                    transfer_reference: value.transfer_reference?,
                    tx: value.tx?,
                    updated_at: value.updated_at?,
                    usd_amount: value.usd_amount?,
                })
            }
        }
        impl ::std::convert::From<super::TransferBaseResponseDto>
        for TransferBaseResponseDto {
            fn from(value: super::TransferBaseResponseDto) -> Self {
                Self {
                    asset: Ok(value.asset),
                    asset_amount: Ok(value.asset_amount),
                    asset_id: Ok(value.asset_id),
                    external_id: Ok(value.external_id),
                    idx: Ok(value.idx),
                    memo: Ok(value.memo),
                    network: Ok(value.network),
                    output_address: Ok(value.output_address),
                    timestamp: Ok(value.timestamp),
                    transfer_reference: Ok(value.transfer_reference),
                    tx: Ok(value.tx),
                    updated_at: Ok(value.updated_at),
                    usd_amount: Ok(value.usd_amount),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct TransferDirectExposureResponseDto {
            direct: ::std::result::Result<
                super::DirectExposureDetail,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for TransferDirectExposureResponseDto {
            fn default() -> Self {
                Self {
                    direct: Err("no value supplied for direct".to_string()),
                }
            }
        }
        impl TransferDirectExposureResponseDto {
            pub fn direct<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<super::DirectExposureDetail>,
                T::Error: ::std::fmt::Display,
            {
                self.direct = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for direct: {}", e)
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<TransferDirectExposureResponseDto>
        for super::TransferDirectExposureResponseDto {
            type Error = super::error::ConversionError;
            fn try_from(
                value: TransferDirectExposureResponseDto,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self { direct: value.direct? })
            }
        }
        impl ::std::convert::From<super::TransferDirectExposureResponseDto>
        for TransferDirectExposureResponseDto {
            fn from(value: super::TransferDirectExposureResponseDto) -> Self {
                Self { direct: Ok(value.direct) }
            }
        }
        #[derive(Clone, Debug)]
        pub struct TransferNetworkIdentificationsResponseDto {
            count: ::std::result::Result<i64, ::std::string::String>,
            network_identification_orgs: ::std::result::Result<
                ::std::vec::Vec<super::NetworkIdentificationOrg>,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for TransferNetworkIdentificationsResponseDto {
            fn default() -> Self {
                Self {
                    count: Err("no value supplied for count".to_string()),
                    network_identification_orgs: Err(
                        "no value supplied for network_identification_orgs".to_string(),
                    ),
                }
            }
        }
        impl TransferNetworkIdentificationsResponseDto {
            pub fn count<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<i64>,
                T::Error: ::std::fmt::Display,
            {
                self.count = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for count: {}", e)
                    });
                self
            }
            pub fn network_identification_orgs<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<
                    ::std::vec::Vec<super::NetworkIdentificationOrg>,
                >,
                T::Error: ::std::fmt::Display,
            {
                self.network_identification_orgs = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for network_identification_orgs: {}",
                            e
                        )
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<TransferNetworkIdentificationsResponseDto>
        for super::TransferNetworkIdentificationsResponseDto {
            type Error = super::error::ConversionError;
            fn try_from(
                value: TransferNetworkIdentificationsResponseDto,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    count: value.count?,
                    network_identification_orgs: value.network_identification_orgs?,
                })
            }
        }
        impl ::std::convert::From<super::TransferNetworkIdentificationsResponseDto>
        for TransferNetworkIdentificationsResponseDto {
            fn from(value: super::TransferNetworkIdentificationsResponseDto) -> Self {
                Self {
                    count: Ok(value.count),
                    network_identification_orgs: Ok(value.network_identification_orgs),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct UpdateEndpointInput {
            channels: ::std::result::Result<
                ::std::vec::Vec<super::UpdateEndpointInputChannelsItem>,
                ::std::string::String,
            >,
            description: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            disabled: ::std::result::Result<bool, ::std::string::String>,
            endpoint_id: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            filter: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            filter_types: ::std::result::Result<
                ::std::vec::Vec<::std::string::String>,
                ::std::string::String,
            >,
            metadata: ::std::result::Result<
                ::serde_json::Map<::std::string::String, ::serde_json::Value>,
                ::std::string::String,
            >,
            rate_limit: ::std::result::Result<
                ::std::option::Option<i64>,
                ::std::string::String,
            >,
            url: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for UpdateEndpointInput {
            fn default() -> Self {
                Self {
                    channels: Ok(Default::default()),
                    description: Ok(Default::default()),
                    disabled: Ok(Default::default()),
                    endpoint_id: Ok(Default::default()),
                    filter: Ok(Default::default()),
                    filter_types: Ok(Default::default()),
                    metadata: Ok(Default::default()),
                    rate_limit: Ok(Default::default()),
                    url: Ok(Default::default()),
                }
            }
        }
        impl UpdateEndpointInput {
            pub fn channels<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<
                    ::std::vec::Vec<super::UpdateEndpointInputChannelsItem>,
                >,
                T::Error: ::std::fmt::Display,
            {
                self.channels = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for channels: {}", e)
                    });
                self
            }
            pub fn description<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.description = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for description: {}", e)
                    });
                self
            }
            pub fn disabled<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<bool>,
                T::Error: ::std::fmt::Display,
            {
                self.disabled = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for disabled: {}", e)
                    });
                self
            }
            pub fn endpoint_id<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.endpoint_id = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for endpoint_id: {}", e)
                    });
                self
            }
            pub fn filter<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.filter = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for filter: {}", e)
                    });
                self
            }
            pub fn filter_types<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::vec::Vec<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.filter_types = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for filter_types: {}", e
                        )
                    });
                self
            }
            pub fn metadata<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<
                    ::serde_json::Map<::std::string::String, ::serde_json::Value>,
                >,
                T::Error: ::std::fmt::Display,
            {
                self.metadata = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for metadata: {}", e)
                    });
                self
            }
            pub fn rate_limit<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<i64>>,
                T::Error: ::std::fmt::Display,
            {
                self.rate_limit = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for rate_limit: {}", e)
                    });
                self
            }
            pub fn url<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.url = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for url: {}", e)
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<UpdateEndpointInput>
        for super::UpdateEndpointInput {
            type Error = super::error::ConversionError;
            fn try_from(
                value: UpdateEndpointInput,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    channels: value.channels?,
                    description: value.description?,
                    disabled: value.disabled?,
                    endpoint_id: value.endpoint_id?,
                    filter: value.filter?,
                    filter_types: value.filter_types?,
                    metadata: value.metadata?,
                    rate_limit: value.rate_limit?,
                    url: value.url?,
                })
            }
        }
        impl ::std::convert::From<super::UpdateEndpointInput> for UpdateEndpointInput {
            fn from(value: super::UpdateEndpointInput) -> Self {
                Self {
                    channels: Ok(value.channels),
                    description: Ok(value.description),
                    disabled: Ok(value.disabled),
                    endpoint_id: Ok(value.endpoint_id),
                    filter: Ok(value.filter),
                    filter_types: Ok(value.filter_types),
                    metadata: Ok(value.metadata),
                    rate_limit: Ok(value.rate_limit),
                    url: Ok(value.url),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct WalletFirstTxDto {
            wallets: ::std::result::Result<
                ::std::collections::HashMap<
                    ::std::string::String,
                    super::WalletFirstTxItemDto,
                >,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for WalletFirstTxDto {
            fn default() -> Self {
                Self {
                    wallets: Err("no value supplied for wallets".to_string()),
                }
            }
        }
        impl WalletFirstTxDto {
            pub fn wallets<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<
                    ::std::collections::HashMap<
                        ::std::string::String,
                        super::WalletFirstTxItemDto,
                    >,
                >,
                T::Error: ::std::fmt::Display,
            {
                self.wallets = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for wallets: {}", e)
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<WalletFirstTxDto> for super::WalletFirstTxDto {
            type Error = super::error::ConversionError;
            fn try_from(
                value: WalletFirstTxDto,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self { wallets: value.wallets? })
            }
        }
        impl ::std::convert::From<super::WalletFirstTxDto> for WalletFirstTxDto {
            fn from(value: super::WalletFirstTxDto) -> Self {
                Self { wallets: Ok(value.wallets) }
            }
        }
        #[derive(Clone, Debug)]
        pub struct WalletFirstTxItemDto {
            balance_change: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            block_number: ::std::result::Result<i64, ::std::string::String>,
            block_time: ::std::result::Result<i64, ::std::string::String>,
            decimals: ::std::result::Result<i64, ::std::string::String>,
            token_address: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            tx_hash: ::std::result::Result<::std::string::String, ::std::string::String>,
        }
        impl ::std::default::Default for WalletFirstTxItemDto {
            fn default() -> Self {
                Self {
                    balance_change: Err(
                        "no value supplied for balance_change".to_string(),
                    ),
                    block_number: Err("no value supplied for block_number".to_string()),
                    block_time: Err("no value supplied for block_time".to_string()),
                    decimals: Err("no value supplied for decimals".to_string()),
                    token_address: Err(
                        "no value supplied for token_address".to_string(),
                    ),
                    tx_hash: Err("no value supplied for tx_hash".to_string()),
                }
            }
        }
        impl WalletFirstTxItemDto {
            pub fn balance_change<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.balance_change = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for balance_change: {}", e
                        )
                    });
                self
            }
            pub fn block_number<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<i64>,
                T::Error: ::std::fmt::Display,
            {
                self.block_number = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for block_number: {}", e
                        )
                    });
                self
            }
            pub fn block_time<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<i64>,
                T::Error: ::std::fmt::Display,
            {
                self.block_time = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for block_time: {}", e)
                    });
                self
            }
            pub fn decimals<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<i64>,
                T::Error: ::std::fmt::Display,
            {
                self.decimals = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for decimals: {}", e)
                    });
                self
            }
            pub fn token_address<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.token_address = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for token_address: {}", e
                        )
                    });
                self
            }
            pub fn tx_hash<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.tx_hash = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for tx_hash: {}", e)
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<WalletFirstTxItemDto>
        for super::WalletFirstTxItemDto {
            type Error = super::error::ConversionError;
            fn try_from(
                value: WalletFirstTxItemDto,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    balance_change: value.balance_change?,
                    block_number: value.block_number?,
                    block_time: value.block_time?,
                    decimals: value.decimals?,
                    token_address: value.token_address?,
                    tx_hash: value.tx_hash?,
                })
            }
        }
        impl ::std::convert::From<super::WalletFirstTxItemDto> for WalletFirstTxItemDto {
            fn from(value: super::WalletFirstTxItemDto) -> Self {
                Self {
                    balance_change: Ok(value.balance_change),
                    block_number: Ok(value.block_number),
                    block_time: Ok(value.block_time),
                    decimals: Ok(value.decimals),
                    token_address: Ok(value.token_address),
                    tx_hash: Ok(value.tx_hash),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct WalletNetWorthChartDto {
            current_timestamp: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            history: ::std::result::Result<
                ::std::vec::Vec<super::WalletNetWorthHistoryItemDto>,
                ::std::string::String,
            >,
            past_timestamp: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            wallet_address: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for WalletNetWorthChartDto {
            fn default() -> Self {
                Self {
                    current_timestamp: Err(
                        "no value supplied for current_timestamp".to_string(),
                    ),
                    history: Err("no value supplied for history".to_string()),
                    past_timestamp: Err(
                        "no value supplied for past_timestamp".to_string(),
                    ),
                    wallet_address: Err(
                        "no value supplied for wallet_address".to_string(),
                    ),
                }
            }
        }
        impl WalletNetWorthChartDto {
            pub fn current_timestamp<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.current_timestamp = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for current_timestamp: {}",
                            e
                        )
                    });
                self
            }
            pub fn history<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<
                    ::std::vec::Vec<super::WalletNetWorthHistoryItemDto>,
                >,
                T::Error: ::std::fmt::Display,
            {
                self.history = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for history: {}", e)
                    });
                self
            }
            pub fn past_timestamp<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.past_timestamp = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for past_timestamp: {}", e
                        )
                    });
                self
            }
            pub fn wallet_address<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.wallet_address = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for wallet_address: {}", e
                        )
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<WalletNetWorthChartDto>
        for super::WalletNetWorthChartDto {
            type Error = super::error::ConversionError;
            fn try_from(
                value: WalletNetWorthChartDto,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    current_timestamp: value.current_timestamp?,
                    history: value.history?,
                    past_timestamp: value.past_timestamp?,
                    wallet_address: value.wallet_address?,
                })
            }
        }
        impl ::std::convert::From<super::WalletNetWorthChartDto>
        for WalletNetWorthChartDto {
            fn from(value: super::WalletNetWorthChartDto) -> Self {
                Self {
                    current_timestamp: Ok(value.current_timestamp),
                    history: Ok(value.history),
                    past_timestamp: Ok(value.past_timestamp),
                    wallet_address: Ok(value.wallet_address),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct WalletNetWorthDetailsPage {
            data: ::std::result::Result<
                ::std::vec::Vec<super::WalletNetWorthItemDto>,
                ::std::string::String,
            >,
            end_cursor: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            has_next: ::std::result::Result<bool, ::std::string::String>,
            has_prev: ::std::result::Result<bool, ::std::string::String>,
            net_worth: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            requested_timestamp: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            resolved_timestamp: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            start_cursor: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            total: ::std::result::Result<i64, ::std::string::String>,
            wallet_address: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for WalletNetWorthDetailsPage {
            fn default() -> Self {
                Self {
                    data: Err("no value supplied for data".to_string()),
                    end_cursor: Ok(Default::default()),
                    has_next: Ok(Default::default()),
                    has_prev: Ok(Default::default()),
                    net_worth: Err("no value supplied for net_worth".to_string()),
                    requested_timestamp: Err(
                        "no value supplied for requested_timestamp".to_string(),
                    ),
                    resolved_timestamp: Err(
                        "no value supplied for resolved_timestamp".to_string(),
                    ),
                    start_cursor: Ok(Default::default()),
                    total: Ok(Default::default()),
                    wallet_address: Err(
                        "no value supplied for wallet_address".to_string(),
                    ),
                }
            }
        }
        impl WalletNetWorthDetailsPage {
            pub fn data<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<
                    ::std::vec::Vec<super::WalletNetWorthItemDto>,
                >,
                T::Error: ::std::fmt::Display,
            {
                self.data = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for data: {}", e)
                    });
                self
            }
            pub fn end_cursor<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.end_cursor = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for end_cursor: {}", e)
                    });
                self
            }
            pub fn has_next<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<bool>,
                T::Error: ::std::fmt::Display,
            {
                self.has_next = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for has_next: {}", e)
                    });
                self
            }
            pub fn has_prev<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<bool>,
                T::Error: ::std::fmt::Display,
            {
                self.has_prev = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for has_prev: {}", e)
                    });
                self
            }
            pub fn net_worth<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.net_worth = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for net_worth: {}", e)
                    });
                self
            }
            pub fn requested_timestamp<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.requested_timestamp = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for requested_timestamp: {}",
                            e
                        )
                    });
                self
            }
            pub fn resolved_timestamp<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.resolved_timestamp = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for resolved_timestamp: {}",
                            e
                        )
                    });
                self
            }
            pub fn start_cursor<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.start_cursor = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for start_cursor: {}", e
                        )
                    });
                self
            }
            pub fn total<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<i64>,
                T::Error: ::std::fmt::Display,
            {
                self.total = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for total: {}", e)
                    });
                self
            }
            pub fn wallet_address<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.wallet_address = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for wallet_address: {}", e
                        )
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<WalletNetWorthDetailsPage>
        for super::WalletNetWorthDetailsPage {
            type Error = super::error::ConversionError;
            fn try_from(
                value: WalletNetWorthDetailsPage,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    data: value.data?,
                    end_cursor: value.end_cursor?,
                    has_next: value.has_next?,
                    has_prev: value.has_prev?,
                    net_worth: value.net_worth?,
                    requested_timestamp: value.requested_timestamp?,
                    resolved_timestamp: value.resolved_timestamp?,
                    start_cursor: value.start_cursor?,
                    total: value.total?,
                    wallet_address: value.wallet_address?,
                })
            }
        }
        impl ::std::convert::From<super::WalletNetWorthDetailsPage>
        for WalletNetWorthDetailsPage {
            fn from(value: super::WalletNetWorthDetailsPage) -> Self {
                Self {
                    data: Ok(value.data),
                    end_cursor: Ok(value.end_cursor),
                    has_next: Ok(value.has_next),
                    has_prev: Ok(value.has_prev),
                    net_worth: Ok(value.net_worth),
                    requested_timestamp: Ok(value.requested_timestamp),
                    resolved_timestamp: Ok(value.resolved_timestamp),
                    start_cursor: Ok(value.start_cursor),
                    total: Ok(value.total),
                    wallet_address: Ok(value.wallet_address),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct WalletNetWorthHistoryItemDto {
            net_worth: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            net_worth_change: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            net_worth_change_percent: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            timestamp: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for WalletNetWorthHistoryItemDto {
            fn default() -> Self {
                Self {
                    net_worth: Err("no value supplied for net_worth".to_string()),
                    net_worth_change: Err(
                        "no value supplied for net_worth_change".to_string(),
                    ),
                    net_worth_change_percent: Err(
                        "no value supplied for net_worth_change_percent".to_string(),
                    ),
                    timestamp: Err("no value supplied for timestamp".to_string()),
                }
            }
        }
        impl WalletNetWorthHistoryItemDto {
            pub fn net_worth<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.net_worth = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for net_worth: {}", e)
                    });
                self
            }
            pub fn net_worth_change<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.net_worth_change = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for net_worth_change: {}", e
                        )
                    });
                self
            }
            pub fn net_worth_change_percent<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.net_worth_change_percent = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for net_worth_change_percent: {}",
                            e
                        )
                    });
                self
            }
            pub fn timestamp<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.timestamp = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for timestamp: {}", e)
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<WalletNetWorthHistoryItemDto>
        for super::WalletNetWorthHistoryItemDto {
            type Error = super::error::ConversionError;
            fn try_from(
                value: WalletNetWorthHistoryItemDto,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    net_worth: value.net_worth?,
                    net_worth_change: value.net_worth_change?,
                    net_worth_change_percent: value.net_worth_change_percent?,
                    timestamp: value.timestamp?,
                })
            }
        }
        impl ::std::convert::From<super::WalletNetWorthHistoryItemDto>
        for WalletNetWorthHistoryItemDto {
            fn from(value: super::WalletNetWorthHistoryItemDto) -> Self {
                Self {
                    net_worth: Ok(value.net_worth),
                    net_worth_change: Ok(value.net_worth_change),
                    net_worth_change_percent: Ok(value.net_worth_change_percent),
                    timestamp: Ok(value.timestamp),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct WalletNetWorthItemDto {
            amount: ::std::result::Result<::std::string::String, ::std::string::String>,
            chain: ::std::result::Result<::std::string::String, ::std::string::String>,
            decimals: ::std::result::Result<i64, ::std::string::String>,
            logo_uri: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            name: ::std::result::Result<::std::string::String, ::std::string::String>,
            price_in_native: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            price_in_usd: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            symbol: ::std::result::Result<::std::string::String, ::std::string::String>,
            token_address: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            value_in_native: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            value_in_usd: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for WalletNetWorthItemDto {
            fn default() -> Self {
                Self {
                    amount: Err("no value supplied for amount".to_string()),
                    chain: Err("no value supplied for chain".to_string()),
                    decimals: Err("no value supplied for decimals".to_string()),
                    logo_uri: Ok(Default::default()),
                    name: Err("no value supplied for name".to_string()),
                    price_in_native: Err(
                        "no value supplied for price_in_native".to_string(),
                    ),
                    price_in_usd: Err("no value supplied for price_in_usd".to_string()),
                    symbol: Err("no value supplied for symbol".to_string()),
                    token_address: Err(
                        "no value supplied for token_address".to_string(),
                    ),
                    value_in_native: Err(
                        "no value supplied for value_in_native".to_string(),
                    ),
                    value_in_usd: Err("no value supplied for value_in_usd".to_string()),
                }
            }
        }
        impl WalletNetWorthItemDto {
            pub fn amount<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.amount = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for amount: {}", e)
                    });
                self
            }
            pub fn chain<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.chain = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for chain: {}", e)
                    });
                self
            }
            pub fn decimals<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<i64>,
                T::Error: ::std::fmt::Display,
            {
                self.decimals = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for decimals: {}", e)
                    });
                self
            }
            pub fn logo_uri<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.logo_uri = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for logo_uri: {}", e)
                    });
                self
            }
            pub fn name<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.name = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for name: {}", e)
                    });
                self
            }
            pub fn price_in_native<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.price_in_native = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for price_in_native: {}", e
                        )
                    });
                self
            }
            pub fn price_in_usd<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.price_in_usd = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for price_in_usd: {}", e
                        )
                    });
                self
            }
            pub fn symbol<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.symbol = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for symbol: {}", e)
                    });
                self
            }
            pub fn token_address<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.token_address = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for token_address: {}", e
                        )
                    });
                self
            }
            pub fn value_in_native<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.value_in_native = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for value_in_native: {}", e
                        )
                    });
                self
            }
            pub fn value_in_usd<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.value_in_usd = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for value_in_usd: {}", e
                        )
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<WalletNetWorthItemDto>
        for super::WalletNetWorthItemDto {
            type Error = super::error::ConversionError;
            fn try_from(
                value: WalletNetWorthItemDto,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    amount: value.amount?,
                    chain: value.chain?,
                    decimals: value.decimals?,
                    logo_uri: value.logo_uri?,
                    name: value.name?,
                    price_in_native: value.price_in_native?,
                    price_in_usd: value.price_in_usd?,
                    symbol: value.symbol?,
                    token_address: value.token_address?,
                    value_in_native: value.value_in_native?,
                    value_in_usd: value.value_in_usd?,
                })
            }
        }
        impl ::std::convert::From<super::WalletNetWorthItemDto>
        for WalletNetWorthItemDto {
            fn from(value: super::WalletNetWorthItemDto) -> Self {
                Self {
                    amount: Ok(value.amount),
                    chain: Ok(value.chain),
                    decimals: Ok(value.decimals),
                    logo_uri: Ok(value.logo_uri),
                    name: Ok(value.name),
                    price_in_native: Ok(value.price_in_native),
                    price_in_usd: Ok(value.price_in_usd),
                    symbol: Ok(value.symbol),
                    token_address: Ok(value.token_address),
                    value_in_native: Ok(value.value_in_native),
                    value_in_usd: Ok(value.value_in_usd),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct WalletNetWorthPage {
            current_timestamp: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            data: ::std::result::Result<
                ::std::vec::Vec<super::WalletNetWorthItemDto>,
                ::std::string::String,
            >,
            end_cursor: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            has_next: ::std::result::Result<bool, ::std::string::String>,
            has_prev: ::std::result::Result<bool, ::std::string::String>,
            start_cursor: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            total: ::std::result::Result<i64, ::std::string::String>,
            total_value_in_native: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            total_value_in_usd: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            wallet_address: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for WalletNetWorthPage {
            fn default() -> Self {
                Self {
                    current_timestamp: Err(
                        "no value supplied for current_timestamp".to_string(),
                    ),
                    data: Err("no value supplied for data".to_string()),
                    end_cursor: Ok(Default::default()),
                    has_next: Ok(Default::default()),
                    has_prev: Ok(Default::default()),
                    start_cursor: Ok(Default::default()),
                    total: Ok(Default::default()),
                    total_value_in_native: Err(
                        "no value supplied for total_value_in_native".to_string(),
                    ),
                    total_value_in_usd: Err(
                        "no value supplied for total_value_in_usd".to_string(),
                    ),
                    wallet_address: Err(
                        "no value supplied for wallet_address".to_string(),
                    ),
                }
            }
        }
        impl WalletNetWorthPage {
            pub fn current_timestamp<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.current_timestamp = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for current_timestamp: {}",
                            e
                        )
                    });
                self
            }
            pub fn data<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<
                    ::std::vec::Vec<super::WalletNetWorthItemDto>,
                >,
                T::Error: ::std::fmt::Display,
            {
                self.data = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for data: {}", e)
                    });
                self
            }
            pub fn end_cursor<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.end_cursor = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for end_cursor: {}", e)
                    });
                self
            }
            pub fn has_next<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<bool>,
                T::Error: ::std::fmt::Display,
            {
                self.has_next = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for has_next: {}", e)
                    });
                self
            }
            pub fn has_prev<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<bool>,
                T::Error: ::std::fmt::Display,
            {
                self.has_prev = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for has_prev: {}", e)
                    });
                self
            }
            pub fn start_cursor<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.start_cursor = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for start_cursor: {}", e
                        )
                    });
                self
            }
            pub fn total<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<i64>,
                T::Error: ::std::fmt::Display,
            {
                self.total = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for total: {}", e)
                    });
                self
            }
            pub fn total_value_in_native<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.total_value_in_native = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for total_value_in_native: {}",
                            e
                        )
                    });
                self
            }
            pub fn total_value_in_usd<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.total_value_in_usd = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for total_value_in_usd: {}",
                            e
                        )
                    });
                self
            }
            pub fn wallet_address<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.wallet_address = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for wallet_address: {}", e
                        )
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<WalletNetWorthPage> for super::WalletNetWorthPage {
            type Error = super::error::ConversionError;
            fn try_from(
                value: WalletNetWorthPage,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    current_timestamp: value.current_timestamp?,
                    data: value.data?,
                    end_cursor: value.end_cursor?,
                    has_next: value.has_next?,
                    has_prev: value.has_prev?,
                    start_cursor: value.start_cursor?,
                    total: value.total?,
                    total_value_in_native: value.total_value_in_native?,
                    total_value_in_usd: value.total_value_in_usd?,
                    wallet_address: value.wallet_address?,
                })
            }
        }
        impl ::std::convert::From<super::WalletNetWorthPage> for WalletNetWorthPage {
            fn from(value: super::WalletNetWorthPage) -> Self {
                Self {
                    current_timestamp: Ok(value.current_timestamp),
                    data: Ok(value.data),
                    end_cursor: Ok(value.end_cursor),
                    has_next: Ok(value.has_next),
                    has_prev: Ok(value.has_prev),
                    start_cursor: Ok(value.start_cursor),
                    total: Ok(value.total),
                    total_value_in_native: Ok(value.total_value_in_native),
                    total_value_in_usd: Ok(value.total_value_in_usd),
                    wallet_address: Ok(value.wallet_address),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct WalletNetWorthSummaryDto {
            current_timestamp: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            wallets: ::std::result::Result<
                ::std::collections::HashMap<
                    ::std::string::String,
                    super::WalletNetWorthSummaryValueDto,
                >,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for WalletNetWorthSummaryDto {
            fn default() -> Self {
                Self {
                    current_timestamp: Err(
                        "no value supplied for current_timestamp".to_string(),
                    ),
                    wallets: Err("no value supplied for wallets".to_string()),
                }
            }
        }
        impl WalletNetWorthSummaryDto {
            pub fn current_timestamp<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.current_timestamp = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for current_timestamp: {}",
                            e
                        )
                    });
                self
            }
            pub fn wallets<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<
                    ::std::collections::HashMap<
                        ::std::string::String,
                        super::WalletNetWorthSummaryValueDto,
                    >,
                >,
                T::Error: ::std::fmt::Display,
            {
                self.wallets = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for wallets: {}", e)
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<WalletNetWorthSummaryDto>
        for super::WalletNetWorthSummaryDto {
            type Error = super::error::ConversionError;
            fn try_from(
                value: WalletNetWorthSummaryDto,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    current_timestamp: value.current_timestamp?,
                    wallets: value.wallets?,
                })
            }
        }
        impl ::std::convert::From<super::WalletNetWorthSummaryDto>
        for WalletNetWorthSummaryDto {
            fn from(value: super::WalletNetWorthSummaryDto) -> Self {
                Self {
                    current_timestamp: Ok(value.current_timestamp),
                    wallets: Ok(value.wallets),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct WalletNetWorthSummaryValueDto {
            value: ::std::result::Result<::std::string::String, ::std::string::String>,
        }
        impl ::std::default::Default for WalletNetWorthSummaryValueDto {
            fn default() -> Self {
                Self {
                    value: Err("no value supplied for value".to_string()),
                }
            }
        }
        impl WalletNetWorthSummaryValueDto {
            pub fn value<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.value = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for value: {}", e)
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<WalletNetWorthSummaryValueDto>
        for super::WalletNetWorthSummaryValueDto {
            type Error = super::error::ConversionError;
            fn try_from(
                value: WalletNetWorthSummaryValueDto,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self { value: value.value? })
            }
        }
        impl ::std::convert::From<super::WalletNetWorthSummaryValueDto>
        for WalletNetWorthSummaryValueDto {
            fn from(value: super::WalletNetWorthSummaryValueDto) -> Self {
                Self { value: Ok(value.value) }
            }
        }
        #[derive(Clone, Debug)]
        pub struct WalletPnlSummaryDto {
            avg_profit_per_trade_in_usd: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            buy_amount_in_usd: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            buys: ::std::result::Result<::std::string::String, ::std::string::String>,
            losses: ::std::result::Result<::std::string::String, ::std::string::String>,
            realized_profit_in_usd: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            realized_profit_ratio: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            resolution: ::std::result::Result<
                super::WalletPnlSummaryDtoResolution,
                ::std::string::String,
            >,
            sell_amount_in_usd: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            sells: ::std::result::Result<::std::string::String, ::std::string::String>,
            tokens: ::std::result::Result<::std::string::String, ::std::string::String>,
            total_cost_in_usd: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            total_profit_in_usd: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            total_profit_ratio: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            total_trades: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            unrealized_profit_in_usd: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            unrealized_profit_ratio: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            updated_at: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            wallet_address: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            win_rate: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            wins: ::std::result::Result<::std::string::String, ::std::string::String>,
        }
        impl ::std::default::Default for WalletPnlSummaryDto {
            fn default() -> Self {
                Self {
                    avg_profit_per_trade_in_usd: Err(
                        "no value supplied for avg_profit_per_trade_in_usd".to_string(),
                    ),
                    buy_amount_in_usd: Err(
                        "no value supplied for buy_amount_in_usd".to_string(),
                    ),
                    buys: Err("no value supplied for buys".to_string()),
                    losses: Err("no value supplied for losses".to_string()),
                    realized_profit_in_usd: Err(
                        "no value supplied for realized_profit_in_usd".to_string(),
                    ),
                    realized_profit_ratio: Err(
                        "no value supplied for realized_profit_ratio".to_string(),
                    ),
                    resolution: Err("no value supplied for resolution".to_string()),
                    sell_amount_in_usd: Err(
                        "no value supplied for sell_amount_in_usd".to_string(),
                    ),
                    sells: Err("no value supplied for sells".to_string()),
                    tokens: Err("no value supplied for tokens".to_string()),
                    total_cost_in_usd: Err(
                        "no value supplied for total_cost_in_usd".to_string(),
                    ),
                    total_profit_in_usd: Err(
                        "no value supplied for total_profit_in_usd".to_string(),
                    ),
                    total_profit_ratio: Err(
                        "no value supplied for total_profit_ratio".to_string(),
                    ),
                    total_trades: Err("no value supplied for total_trades".to_string()),
                    unrealized_profit_in_usd: Err(
                        "no value supplied for unrealized_profit_in_usd".to_string(),
                    ),
                    unrealized_profit_ratio: Err(
                        "no value supplied for unrealized_profit_ratio".to_string(),
                    ),
                    updated_at: Ok(Default::default()),
                    wallet_address: Err(
                        "no value supplied for wallet_address".to_string(),
                    ),
                    win_rate: Err("no value supplied for win_rate".to_string()),
                    wins: Err("no value supplied for wins".to_string()),
                }
            }
        }
        impl WalletPnlSummaryDto {
            pub fn avg_profit_per_trade_in_usd<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.avg_profit_per_trade_in_usd = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for avg_profit_per_trade_in_usd: {}",
                            e
                        )
                    });
                self
            }
            pub fn buy_amount_in_usd<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.buy_amount_in_usd = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for buy_amount_in_usd: {}",
                            e
                        )
                    });
                self
            }
            pub fn buys<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.buys = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for buys: {}", e)
                    });
                self
            }
            pub fn losses<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.losses = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for losses: {}", e)
                    });
                self
            }
            pub fn realized_profit_in_usd<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.realized_profit_in_usd = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for realized_profit_in_usd: {}",
                            e
                        )
                    });
                self
            }
            pub fn realized_profit_ratio<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.realized_profit_ratio = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for realized_profit_ratio: {}",
                            e
                        )
                    });
                self
            }
            pub fn resolution<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<super::WalletPnlSummaryDtoResolution>,
                T::Error: ::std::fmt::Display,
            {
                self.resolution = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for resolution: {}", e)
                    });
                self
            }
            pub fn sell_amount_in_usd<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.sell_amount_in_usd = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for sell_amount_in_usd: {}",
                            e
                        )
                    });
                self
            }
            pub fn sells<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.sells = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for sells: {}", e)
                    });
                self
            }
            pub fn tokens<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.tokens = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for tokens: {}", e)
                    });
                self
            }
            pub fn total_cost_in_usd<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.total_cost_in_usd = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for total_cost_in_usd: {}",
                            e
                        )
                    });
                self
            }
            pub fn total_profit_in_usd<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.total_profit_in_usd = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for total_profit_in_usd: {}",
                            e
                        )
                    });
                self
            }
            pub fn total_profit_ratio<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.total_profit_ratio = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for total_profit_ratio: {}",
                            e
                        )
                    });
                self
            }
            pub fn total_trades<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.total_trades = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for total_trades: {}", e
                        )
                    });
                self
            }
            pub fn unrealized_profit_in_usd<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.unrealized_profit_in_usd = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for unrealized_profit_in_usd: {}",
                            e
                        )
                    });
                self
            }
            pub fn unrealized_profit_ratio<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.unrealized_profit_ratio = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for unrealized_profit_ratio: {}",
                            e
                        )
                    });
                self
            }
            pub fn updated_at<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.updated_at = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for updated_at: {}", e)
                    });
                self
            }
            pub fn wallet_address<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.wallet_address = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for wallet_address: {}", e
                        )
                    });
                self
            }
            pub fn win_rate<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.win_rate = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for win_rate: {}", e)
                    });
                self
            }
            pub fn wins<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.wins = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for wins: {}", e)
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<WalletPnlSummaryDto>
        for super::WalletPnlSummaryDto {
            type Error = super::error::ConversionError;
            fn try_from(
                value: WalletPnlSummaryDto,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    avg_profit_per_trade_in_usd: value.avg_profit_per_trade_in_usd?,
                    buy_amount_in_usd: value.buy_amount_in_usd?,
                    buys: value.buys?,
                    losses: value.losses?,
                    realized_profit_in_usd: value.realized_profit_in_usd?,
                    realized_profit_ratio: value.realized_profit_ratio?,
                    resolution: value.resolution?,
                    sell_amount_in_usd: value.sell_amount_in_usd?,
                    sells: value.sells?,
                    tokens: value.tokens?,
                    total_cost_in_usd: value.total_cost_in_usd?,
                    total_profit_in_usd: value.total_profit_in_usd?,
                    total_profit_ratio: value.total_profit_ratio?,
                    total_trades: value.total_trades?,
                    unrealized_profit_in_usd: value.unrealized_profit_in_usd?,
                    unrealized_profit_ratio: value.unrealized_profit_ratio?,
                    updated_at: value.updated_at?,
                    wallet_address: value.wallet_address?,
                    win_rate: value.win_rate?,
                    wins: value.wins?,
                })
            }
        }
        impl ::std::convert::From<super::WalletPnlSummaryDto> for WalletPnlSummaryDto {
            fn from(value: super::WalletPnlSummaryDto) -> Self {
                Self {
                    avg_profit_per_trade_in_usd: Ok(value.avg_profit_per_trade_in_usd),
                    buy_amount_in_usd: Ok(value.buy_amount_in_usd),
                    buys: Ok(value.buys),
                    losses: Ok(value.losses),
                    realized_profit_in_usd: Ok(value.realized_profit_in_usd),
                    realized_profit_ratio: Ok(value.realized_profit_ratio),
                    resolution: Ok(value.resolution),
                    sell_amount_in_usd: Ok(value.sell_amount_in_usd),
                    sells: Ok(value.sells),
                    tokens: Ok(value.tokens),
                    total_cost_in_usd: Ok(value.total_cost_in_usd),
                    total_profit_in_usd: Ok(value.total_profit_in_usd),
                    total_profit_ratio: Ok(value.total_profit_ratio),
                    total_trades: Ok(value.total_trades),
                    unrealized_profit_in_usd: Ok(value.unrealized_profit_in_usd),
                    unrealized_profit_ratio: Ok(value.unrealized_profit_ratio),
                    updated_at: Ok(value.updated_at),
                    wallet_address: Ok(value.wallet_address),
                    win_rate: Ok(value.win_rate),
                    wins: Ok(value.wins),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct WithdrawalAddressIdentificationsResponseDto {
            chainalysis_identifications: ::std::result::Result<
                ::std::vec::Vec<super::ChainalysisAddressIdentification>,
                ::std::string::String,
            >,
            custom_addresses: ::std::result::Result<
                ::std::vec::Vec<::std::string::String>,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for WithdrawalAddressIdentificationsResponseDto {
            fn default() -> Self {
                Self {
                    chainalysis_identifications: Err(
                        "no value supplied for chainalysis_identifications".to_string(),
                    ),
                    custom_addresses: Err(
                        "no value supplied for custom_addresses".to_string(),
                    ),
                }
            }
        }
        impl WithdrawalAddressIdentificationsResponseDto {
            pub fn chainalysis_identifications<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<
                    ::std::vec::Vec<super::ChainalysisAddressIdentification>,
                >,
                T::Error: ::std::fmt::Display,
            {
                self.chainalysis_identifications = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for chainalysis_identifications: {}",
                            e
                        )
                    });
                self
            }
            pub fn custom_addresses<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::vec::Vec<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.custom_addresses = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for custom_addresses: {}", e
                        )
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<WithdrawalAddressIdentificationsResponseDto>
        for super::WithdrawalAddressIdentificationsResponseDto {
            type Error = super::error::ConversionError;
            fn try_from(
                value: WithdrawalAddressIdentificationsResponseDto,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    chainalysis_identifications: value.chainalysis_identifications?,
                    custom_addresses: value.custom_addresses?,
                })
            }
        }
        impl ::std::convert::From<super::WithdrawalAddressIdentificationsResponseDto>
        for WithdrawalAddressIdentificationsResponseDto {
            fn from(value: super::WithdrawalAddressIdentificationsResponseDto) -> Self {
                Self {
                    chainalysis_identifications: Ok(value.chainalysis_identifications),
                    custom_addresses: Ok(value.custom_addresses),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct WithdrawalBaseResponseDto {
            address: ::std::result::Result<::std::string::String, ::std::string::String>,
            asset: ::std::result::Result<::std::string::String, ::std::string::String>,
            asset_amount: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            asset_id: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            attempt_identifier: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            external_id: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            memo: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            network: ::std::result::Result<::std::string::String, ::std::string::String>,
            updated_at: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            usd_amount: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for WithdrawalBaseResponseDto {
            fn default() -> Self {
                Self {
                    address: Err("no value supplied for address".to_string()),
                    asset: Err("no value supplied for asset".to_string()),
                    asset_amount: Err("no value supplied for asset_amount".to_string()),
                    asset_id: Err("no value supplied for asset_id".to_string()),
                    attempt_identifier: Err(
                        "no value supplied for attempt_identifier".to_string(),
                    ),
                    external_id: Err("no value supplied for external_id".to_string()),
                    memo: Err("no value supplied for memo".to_string()),
                    network: Err("no value supplied for network".to_string()),
                    updated_at: Err("no value supplied for updated_at".to_string()),
                    usd_amount: Err("no value supplied for usd_amount".to_string()),
                }
            }
        }
        impl WithdrawalBaseResponseDto {
            pub fn address<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.address = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for address: {}", e)
                    });
                self
            }
            pub fn asset<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.asset = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for asset: {}", e)
                    });
                self
            }
            pub fn asset_amount<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.asset_amount = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for asset_amount: {}", e
                        )
                    });
                self
            }
            pub fn asset_id<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.asset_id = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for asset_id: {}", e)
                    });
                self
            }
            pub fn attempt_identifier<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.attempt_identifier = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for attempt_identifier: {}",
                            e
                        )
                    });
                self
            }
            pub fn external_id<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.external_id = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for external_id: {}", e)
                    });
                self
            }
            pub fn memo<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.memo = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for memo: {}", e)
                    });
                self
            }
            pub fn network<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.network = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for network: {}", e)
                    });
                self
            }
            pub fn updated_at<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.updated_at = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for updated_at: {}", e)
                    });
                self
            }
            pub fn usd_amount<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.usd_amount = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for usd_amount: {}", e)
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<WithdrawalBaseResponseDto>
        for super::WithdrawalBaseResponseDto {
            type Error = super::error::ConversionError;
            fn try_from(
                value: WithdrawalBaseResponseDto,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    address: value.address?,
                    asset: value.asset?,
                    asset_amount: value.asset_amount?,
                    asset_id: value.asset_id?,
                    attempt_identifier: value.attempt_identifier?,
                    external_id: value.external_id?,
                    memo: value.memo?,
                    network: value.network?,
                    updated_at: value.updated_at?,
                    usd_amount: value.usd_amount?,
                })
            }
        }
        impl ::std::convert::From<super::WithdrawalBaseResponseDto>
        for WithdrawalBaseResponseDto {
            fn from(value: super::WithdrawalBaseResponseDto) -> Self {
                Self {
                    address: Ok(value.address),
                    asset: Ok(value.asset),
                    asset_amount: Ok(value.asset_amount),
                    asset_id: Ok(value.asset_id),
                    attempt_identifier: Ok(value.attempt_identifier),
                    external_id: Ok(value.external_id),
                    memo: Ok(value.memo),
                    network: Ok(value.network),
                    updated_at: Ok(value.updated_at),
                    usd_amount: Ok(value.usd_amount),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct WithdrawalFraudAssessmentResponseDto {
            alterya_identifications: ::std::result::Result<
                ::std::vec::Vec<super::AlteryaIdentification>,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for WithdrawalFraudAssessmentResponseDto {
            fn default() -> Self {
                Self {
                    alterya_identifications: Err(
                        "no value supplied for alterya_identifications".to_string(),
                    ),
                }
            }
        }
        impl WithdrawalFraudAssessmentResponseDto {
            pub fn alterya_identifications<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<
                    ::std::vec::Vec<super::AlteryaIdentification>,
                >,
                T::Error: ::std::fmt::Display,
            {
                self.alterya_identifications = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for alterya_identifications: {}",
                            e
                        )
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<WithdrawalFraudAssessmentResponseDto>
        for super::WithdrawalFraudAssessmentResponseDto {
            type Error = super::error::ConversionError;
            fn try_from(
                value: WithdrawalFraudAssessmentResponseDto,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    alterya_identifications: value.alterya_identifications?,
                })
            }
        }
        impl ::std::convert::From<super::WithdrawalFraudAssessmentResponseDto>
        for WithdrawalFraudAssessmentResponseDto {
            fn from(value: super::WithdrawalFraudAssessmentResponseDto) -> Self {
                Self {
                    alterya_identifications: Ok(value.alterya_identifications),
                }
            }
        }
    }
}
#[derive(Clone, Debug)]
/**Client for Dex Aggregator API

Dex Aggregator API ⚡️

Version: 1.0*/
pub struct Client {
    pub(crate) baseurl: String,
    pub(crate) client: reqwest_middleware::ClientWithMiddleware,
}
impl Client {
    /// Create a new client.
    ///
    /// `baseurl` is the base URL provided to the internal
    /// `reqwest::Client`, and should include a scheme and hostname,
    /// as well as port and a path stem if applicable.
    pub fn new(baseurl: &str) -> Self {
        #[cfg(not(target_arch = "wasm32"))]
        let client = {
            let dur = std::time::Duration::from_secs(15);
            let reqwest_client = reqwest::ClientBuilder::new()
                .connect_timeout(dur)
                .timeout(dur)
                .build()
                .unwrap();
            reqwest_middleware::ClientBuilder::new(reqwest_client).build()
        };
        #[cfg(target_arch = "wasm32")]
        let client = {
            let reqwest_client = reqwest::ClientBuilder::new().build().unwrap();
            reqwest_middleware::ClientBuilder::new(reqwest_client).build()
        };
        Self::new_with_client(baseurl, client)
    }
    /// Construct a new client with an existing `reqwest_middleware::ClientWithMiddleware`,
    /// allowing more control over its configuration.
    ///
    /// `baseurl` is the base URL provided to the internal
    /// `reqwest_middleware::ClientWithMiddleware`, and should include a scheme and hostname,
    /// as well as port and a path stem if applicable.
    pub fn new_with_client(
        baseurl: &str,
        client: reqwest_middleware::ClientWithMiddleware,
    ) -> Self {
        Self {
            baseurl: baseurl.to_string(),
            client,
        }
    }
}
impl ClientInfo<()> for Client {
    fn api_version() -> &'static str {
        "1.0"
    }
    fn baseurl(&self) -> &str {
        self.baseurl.as_str()
    }
    fn client(&self) -> &reqwest_middleware::ClientWithMiddleware {
        &self.client
    }
    fn inner(&self) -> &() {
        &()
    }
}
impl ClientHooks<()> for &Client {}
impl Client {
    /**CONTROLLER.GET_SUPPORTED_BLOCKCHAINS.SUMMARY

CONTROLLER.GET_SUPPORTED_BLOCKCHAINS.DESCRIPTION

Sends a `GET` request to `/v1/blockchain`

```ignore
let response = client.get_supported_blockchains()
    .send()
    .await;
```*/
    pub fn get_supported_blockchains(&self) -> builder::GetSupportedBlockchains<'_> {
        builder::GetSupportedBlockchains::new(self)
    }
    /**CONTROLLER.GET_LATEST_BLOCK.SUMMARY

CONTROLLER.GET_LATEST_BLOCK.DESCRIPTION

Sends a `GET` request to `/v1/blockchain/{chain}/latest_block`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
```ignore
let response = client.get_latest_block()
    .chain(chain)
    .send()
    .await;
```*/
    pub fn get_latest_block(&self) -> builder::GetLatestBlock<'_> {
        builder::GetLatestBlock::new(self)
    }
    /**CONTROLLER.DEX.LIST.SUMMARY

CONTROLLER.DEX.LIST.DESCRIPTION

Sends a `GET` request to `/v1/dex`

Arguments:
- `chains`
- `dex_program`: DTO.DEX.QUERY.DEX_PROGRAM
- `limit`: DTO.DEX.QUERY.LIMIT
```ignore
let response = client.list_dex()
    .chains(chains)
    .dex_program(dex_program)
    .limit(limit)
    .send()
    .await;
```*/
    pub fn list_dex(&self) -> builder::ListDex<'_> {
        builder::ListDex::new(self)
    }
    /**CONTROLLER.DEX.CREATE.SUMMARY

CONTROLLER.DEX.CREATE.DESCRIPTION

Sends a `POST` request to `/v1/dex/{chain}/create`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
- `body`: Token creation parameters
```ignore
let response = client.create_token()
    .chain(chain)
    .body(body)
    .send()
    .await;
```*/
    pub fn create_token(&self) -> builder::CreateToken<'_> {
        builder::CreateToken::new(self)
    }
    /**CONTROLLER.DEX.QUOTE.SUMMARY

CONTROLLER.DEX.QUOTE.DESCRIPTION

Sends a `GET` request to `/v1/dex/{chain}/quote`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
- `amount`: DTO.DEX.QUOTE.AMOUNT
- `dex`: DTO.DEX.QUOTE.DEX
- `exact_in`: DTO.DEX.QUOTE.EXACT_IN
- `input_mint`: DTO.DEX.QUOTE.INPUT_MINT
- `output_mint`: DTO.DEX.QUOTE.OUTPUT_MINT
- `slippage`: DTO.DEX.QUOTE.SLIPPAGE
```ignore
let response = client.quote()
    .chain(chain)
    .amount(amount)
    .dex(dex)
    .exact_in(exact_in)
    .input_mint(input_mint)
    .output_mint(output_mint)
    .slippage(slippage)
    .send()
    .await;
```*/
    pub fn quote(&self) -> builder::Quote<'_> {
        builder::Quote::new(self)
    }
    /**CONTROLLER.DEX.ROUTE.SUMMARY

CONTROLLER.DEX.ROUTE.DESCRIPTION

Sends a `POST` request to `/v1/dex/{chain}/route`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
- `body`
```ignore
let response = client.route()
    .chain(chain)
    .body(body)
    .send()
    .await;
```*/
    pub fn route(&self) -> builder::Route<'_> {
        builder::Route::new(self)
    }
    /**CONTROLLER.DEX.SWAP.SUMMARY

CONTROLLER.DEX.SWAP.DESCRIPTION

Sends a `POST` request to `/v1/dex/{chain}/swap`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
- `body`
```ignore
let response = client.swap()
    .chain(chain)
    .body(body)
    .send()
    .await;
```*/
    pub fn swap(&self) -> builder::Swap<'_> {
        builder::Swap::new(self)
    }
    /**CONTROLLER.DEXPOOL.GET.SUMMARY

CONTROLLER.DEXPOOL.GET.DESCRIPTION

Sends a `GET` request to `/v1/dexpools/{chain}/{poolAddress}`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
- `pool_address`: GLOBAL.POOLADDRESS.DESCRIPTION
```ignore
let response = client.get_dexpool()
    .chain(chain)
    .pool_address(pool_address)
    .send()
    .await;
```*/
    pub fn get_dexpool(&self) -> builder::GetDexpool<'_> {
        builder::GetDexpool::new(self)
    }
    /**CONTROLLER.DEXPOOL.SNAPSHOTS.SUMMARY

CONTROLLER.DEXPOOL.SNAPSHOTS.DESCRIPTION

Sends a `GET` request to `/v1/dexpools/{chain}/{poolAddress}/snapshots`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
- `pool_address`: GLOBAL.POOLADDRESS.DESCRIPTION
- `cursor`: DTO.PAGE.CURSOR.DESCRIPTION
- `direction`: DTO.PAGE.DIRECTION
- `limit`: DTO.PAGE.LIMIT
- `time`: DTO.DEXPOOL.SNAPSHOT.TIME
```ignore
let response = client.get_dexpool_snapshots()
    .chain(chain)
    .pool_address(pool_address)
    .cursor(cursor)
    .direction(direction)
    .limit(limit)
    .time(time)
    .send()
    .await;
```*/
    pub fn get_dexpool_snapshots(&self) -> builder::GetDexpoolSnapshots<'_> {
        builder::GetDexpoolSnapshots::new(self)
    }
    /**CONTROLLER.IPFS.PRESIGN.SUMMARY

CONTROLLER.IPFS.PRESIGN.DESCRIPTION

Sends a `POST` request to `/v1/ipfs/presign`

```ignore
let response = client.presign()
    .send()
    .await;
```*/
    pub fn presign(&self) -> builder::Presign<'_> {
        builder::Presign::new(self)
    }
    /**CONTROLLER.JOB.GET.SUMMARY

CONTROLLER.JOB.GET.DESCRIPTION

Sends a `GET` request to `/v1/jobs/{id}`

Arguments:
- `id`: CONTROLLER.JOB.GET.ID
```ignore
let response = client.get()
    .id(id)
    .send()
    .await;
```*/
    pub fn get(&self) -> builder::Get<'_> {
        builder::Get::new(self)
    }
    /**CONTROLLER.JOB.STREAMING.SUMMARY

CONTROLLER.JOB.STREAMING.DESCRIPTION

Sends a `GET` request to `/v1/jobs/{id}/streaming`

Arguments:
- `id`: CONTROLLER.JOB.GET.ID
```ignore
let response = client.streaming()
    .id(id)
    .send()
    .await;
```*/
    pub fn streaming(&self) -> builder::Streaming<'_> {
        builder::Streaming::new(self)
    }
    /**CONTROLLER.KYT.REGISTER_ADDRESS.SUMMARY

CONTROLLER.KYT.REGISTER_ADDRESS.DESCRIPTION

Sends a `POST` request to `/v1/kyt/address`

```ignore
let response = client.register_address()
    .body(body)
    .send()
    .await;
```*/
    pub fn register_address(&self) -> builder::RegisterAddress<'_> {
        builder::RegisterAddress::new(self)
    }
    /**CONTROLLER.KYT.GET_ADDRESS_RISK.SUMMARY

CONTROLLER.KYT.GET_ADDRESS_RISK.DESCRIPTION

Sends a `GET` request to `/v1/kyt/addresses/{address}/risk`

Arguments:
- `address`: CONTROLLER.KYT.PARAM.ADDRESS
```ignore
let response = client.get_address_risk()
    .address(address)
    .send()
    .await;
```*/
    pub fn get_address_risk(&self) -> builder::GetAddressRisk<'_> {
        builder::GetAddressRisk::new(self)
    }
    /**CONTROLLER.KYT.REGISTER_TRANSFER.SUMMARY

CONTROLLER.KYT.REGISTER_TRANSFER.DESCRIPTION

Sends a `POST` request to `/v1/kyt/transfer`

```ignore
let response = client.register_transfer()
    .body(body)
    .send()
    .await;
```*/
    pub fn register_transfer(&self) -> builder::RegisterTransfer<'_> {
        builder::RegisterTransfer::new(self)
    }
    /**CONTROLLER.KYT.GET_TRANSFER_ALERTS.SUMMARY

CONTROLLER.KYT.GET_TRANSFER_ALERTS.DESCRIPTION

Sends a `GET` request to `/v1/kyt/transfers/{transferId}/alerts`

Arguments:
- `transfer_id`: CONTROLLER.KYT.PARAM.TRANSFER_ID
```ignore
let response = client.get_transfer_alerts()
    .transfer_id(transfer_id)
    .send()
    .await;
```*/
    pub fn get_transfer_alerts(&self) -> builder::GetTransferAlerts<'_> {
        builder::GetTransferAlerts::new(self)
    }
    /**CONTROLLER.KYT.GET_TRANSFER_DIRECT_EXPOSURE.SUMMARY

CONTROLLER.KYT.GET_TRANSFER_DIRECT_EXPOSURE.DESCRIPTION

Sends a `GET` request to `/v1/kyt/transfers/{transferId}/exposures/direct`

Arguments:
- `transfer_id`: CONTROLLER.KYT.PARAM.TRANSFER_ID
```ignore
let response = client.get_transfer_direct_exposure()
    .transfer_id(transfer_id)
    .send()
    .await;
```*/
    pub fn get_transfer_direct_exposure(
        &self,
    ) -> builder::GetTransferDirectExposure<'_> {
        builder::GetTransferDirectExposure::new(self)
    }
    /**CONTROLLER.KYT.GET_TRANSFER_NETWORK_IDENTIFICATIONS.SUMMARY

CONTROLLER.KYT.GET_TRANSFER_NETWORK_IDENTIFICATIONS.DESCRIPTION

Sends a `GET` request to `/v1/kyt/transfers/{transferId}/network-identifications`

Arguments:
- `transfer_id`: CONTROLLER.KYT.PARAM.TRANSFER_ID
```ignore
let response = client.get_transfer_network_identifications()
    .transfer_id(transfer_id)
    .send()
    .await;
```*/
    pub fn get_transfer_network_identifications(
        &self,
    ) -> builder::GetTransferNetworkIdentifications<'_> {
        builder::GetTransferNetworkIdentifications::new(self)
    }
    /**CONTROLLER.KYT.GET_TRANSFER_SUMMARY.SUMMARY

CONTROLLER.KYT.GET_TRANSFER_SUMMARY.DESCRIPTION

Sends a `GET` request to `/v1/kyt/transfers/{transferId}/summary`

Arguments:
- `transfer_id`: CONTROLLER.KYT.PARAM.TRANSFER_ID
```ignore
let response = client.get_transfer_summary()
    .transfer_id(transfer_id)
    .send()
    .await;
```*/
    pub fn get_transfer_summary(&self) -> builder::GetTransferSummary<'_> {
        builder::GetTransferSummary::new(self)
    }
    /**CONTROLLER.KYT.REGISTER_WITHDRAWAL.SUMMARY

CONTROLLER.KYT.REGISTER_WITHDRAWAL.DESCRIPTION

Sends a `POST` request to `/v1/kyt/withdrawal`

```ignore
let response = client.register_withdrawal()
    .body(body)
    .send()
    .await;
```*/
    pub fn register_withdrawal(&self) -> builder::RegisterWithdrawal<'_> {
        builder::RegisterWithdrawal::new(self)
    }
    /**CONTROLLER.KYT.GET_WITHDRAWAL_ADDRESS_IDENTIFICATIONS.SUMMARY

CONTROLLER.KYT.GET_WITHDRAWAL_ADDRESS_IDENTIFICATIONS.DESCRIPTION

Sends a `GET` request to `/v1/kyt/withdrawal/{withdrawalId}/address-identifications`

Arguments:
- `withdrawal_id`: CONTROLLER.KYT.PARAM.WITHDRAWAL_ID
```ignore
let response = client.get_withdrawal_address_identifications()
    .withdrawal_id(withdrawal_id)
    .send()
    .await;
```*/
    pub fn get_withdrawal_address_identifications(
        &self,
    ) -> builder::GetWithdrawalAddressIdentifications<'_> {
        builder::GetWithdrawalAddressIdentifications::new(self)
    }
    /**CONTROLLER.KYT.GET_WITHDRAWAL_ALERTS.SUMMARY

CONTROLLER.KYT.GET_WITHDRAWAL_ALERTS.DESCRIPTION

Sends a `GET` request to `/v1/kyt/withdrawal/{withdrawalId}/alerts`

Arguments:
- `withdrawal_id`: CONTROLLER.KYT.PARAM.WITHDRAWAL_ID
```ignore
let response = client.get_withdrawal_alerts()
    .withdrawal_id(withdrawal_id)
    .send()
    .await;
```*/
    pub fn get_withdrawal_alerts(&self) -> builder::GetWithdrawalAlerts<'_> {
        builder::GetWithdrawalAlerts::new(self)
    }
    /**CONTROLLER.KYT.GET_WITHDRAWAL_DIRECT_EXPOSURE.SUMMARY

CONTROLLER.KYT.GET_WITHDRAWAL_DIRECT_EXPOSURE.DESCRIPTION

Sends a `GET` request to `/v1/kyt/withdrawal/{withdrawalId}/exposures/direct`

Arguments:
- `withdrawal_id`: CONTROLLER.KYT.PARAM.WITHDRAWAL_ID
```ignore
let response = client.get_withdrawal_direct_exposure()
    .withdrawal_id(withdrawal_id)
    .send()
    .await;
```*/
    pub fn get_withdrawal_direct_exposure(
        &self,
    ) -> builder::GetWithdrawalDirectExposure<'_> {
        builder::GetWithdrawalDirectExposure::new(self)
    }
    /**CONTROLLER.KYT.GET_WITHDRAWAL_FRAUD_ASSESSMENT.SUMMARY

CONTROLLER.KYT.GET_WITHDRAWAL_FRAUD_ASSESSMENT.DESCRIPTION

Sends a `GET` request to `/v1/kyt/withdrawal/{withdrawalId}/fraud-assessment`

Arguments:
- `withdrawal_id`: CONTROLLER.KYT.PARAM.WITHDRAWAL_ID
```ignore
let response = client.get_withdrawal_fraud_assessment()
    .withdrawal_id(withdrawal_id)
    .send()
    .await;
```*/
    pub fn get_withdrawal_fraud_assessment(
        &self,
    ) -> builder::GetWithdrawalFraudAssessment<'_> {
        builder::GetWithdrawalFraudAssessment::new(self)
    }
    /**CONTROLLER.KYT.GET_WITHDRAWAL_NETWORK_IDENTIFICATIONS.SUMMARY

CONTROLLER.KYT.GET_WITHDRAWAL_NETWORK_IDENTIFICATIONS.DESCRIPTION

Sends a `GET` request to `/v1/kyt/withdrawal/{withdrawalId}/network-identifications`

Arguments:
- `withdrawal_id`: CONTROLLER.KYT.PARAM.WITHDRAWAL_ID
```ignore
let response = client.get_withdrawal_network_identifications()
    .withdrawal_id(withdrawal_id)
    .send()
    .await;
```*/
    pub fn get_withdrawal_network_identifications(
        &self,
    ) -> builder::GetWithdrawalNetworkIdentifications<'_> {
        builder::GetWithdrawalNetworkIdentifications::new(self)
    }
    /**CONTROLLER.KYT.GET_WITHDRAWAL_SUMMARY.SUMMARY

CONTROLLER.KYT.GET_WITHDRAWAL_SUMMARY.DESCRIPTION

Sends a `GET` request to `/v1/kyt/withdrawal/{withdrawalId}/summary`

Arguments:
- `withdrawal_id`: CONTROLLER.KYT.PARAM.WITHDRAWAL_ID
```ignore
let response = client.get_withdrawal_summary()
    .withdrawal_id(withdrawal_id)
    .send()
    .await;
```*/
    pub fn get_withdrawal_summary(&self) -> builder::GetWithdrawalSummary<'_> {
        builder::GetWithdrawalSummary::new(self)
    }
    /**CONTROLLER.RANKING.FINAL_STRETCH_TOKENS.SUMMARY

CONTROLLER.RANKING.FINAL_STRETCH_TOKENS.DESCRIPTION

Sends a `GET` request to `/v1/ranking/{chain}/finalStretch`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
- `exclude_keywords`: DTO.TOKEN.FILTER.EXCLUDE_KEYWORDS
- `filters`: DTO.TOKEN.FILTER.FILTERS
- `launchpad_platform`: DTO.TOKEN.FILTER.LAUNCHPAD_PLATFORM
- `range_filters`: DTO.TOKEN.REQUEST.FILTER_BY
- `search_keywords`: DTO.TOKEN.FILTER.SEARCH_KEYWORDS
- `sort_by`: DTO.TOKEN.REQUEST.SORT_BY
- `sort_direction`: DTO.TOKEN.REQUEST.SORT_DIRECTION
- `tag`: DTO.TOKEN.REQUEST.TAG
```ignore
let response = client.get_final_stretch_tokens()
    .chain(chain)
    .exclude_keywords(exclude_keywords)
    .filters(filters)
    .launchpad_platform(launchpad_platform)
    .range_filters(range_filters)
    .search_keywords(search_keywords)
    .sort_by(sort_by)
    .sort_direction(sort_direction)
    .tag(tag)
    .send()
    .await;
```*/
    pub fn get_final_stretch_tokens(&self) -> builder::GetFinalStretchTokens<'_> {
        builder::GetFinalStretchTokens::new(self)
    }
    /**CONTROLLER.RANKING.HOT_TOKENS.SUMMARY

CONTROLLER.RANKING.HOT_TOKENS.DESCRIPTION

Sends a `GET` request to `/v1/ranking/{chain}/hotTokens/{duration}`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
- `duration`: CONTROLLER.RANKING.HOT_TOKENS.DURATION.DESCRIPTION
- `exclude_keywords`: DTO.TOKEN.FILTER.EXCLUDE_KEYWORDS
- `filters`: DTO.TOKEN.FILTER.FILTERS
- `launchpad_platform`: DTO.TOKEN.FILTER.LAUNCHPAD_PLATFORM
- `range_filters`: DTO.TOKEN.REQUEST.FILTER_BY
- `search_keywords`: DTO.TOKEN.FILTER.SEARCH_KEYWORDS
- `sort_by`: DTO.TOKEN.REQUEST.SORT_BY
- `sort_direction`: DTO.TOKEN.REQUEST.SORT_DIRECTION
- `tag`: DTO.TOKEN.REQUEST.TAG
```ignore
let response = client.get_hot_tokens()
    .chain(chain)
    .duration(duration)
    .exclude_keywords(exclude_keywords)
    .filters(filters)
    .launchpad_platform(launchpad_platform)
    .range_filters(range_filters)
    .search_keywords(search_keywords)
    .sort_by(sort_by)
    .sort_direction(sort_direction)
    .tag(tag)
    .send()
    .await;
```*/
    pub fn get_hot_tokens(&self) -> builder::GetHotTokens<'_> {
        builder::GetHotTokens::new(self)
    }
    /**CONTROLLER.RANKING.MIGRATED_TOKENS.SUMMARY

CONTROLLER.RANKING.MIGRATED_TOKENS.DESCRIPTION

Sends a `GET` request to `/v1/ranking/{chain}/migrated`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
- `exclude_keywords`: DTO.TOKEN.FILTER.EXCLUDE_KEYWORDS
- `filters`: DTO.TOKEN.FILTER.FILTERS
- `launchpad_platform`: DTO.TOKEN.FILTER.LAUNCHPAD_PLATFORM
- `range_filters`: DTO.TOKEN.REQUEST.FILTER_BY
- `search_keywords`: DTO.TOKEN.FILTER.SEARCH_KEYWORDS
- `sort_by`: DTO.TOKEN.REQUEST.SORT_BY
- `sort_direction`: DTO.TOKEN.REQUEST.SORT_DIRECTION
- `tag`: DTO.TOKEN.REQUEST.TAG
```ignore
let response = client.get_migrated_tokens()
    .chain(chain)
    .exclude_keywords(exclude_keywords)
    .filters(filters)
    .launchpad_platform(launchpad_platform)
    .range_filters(range_filters)
    .search_keywords(search_keywords)
    .sort_by(sort_by)
    .sort_direction(sort_direction)
    .tag(tag)
    .send()
    .await;
```*/
    pub fn get_migrated_tokens(&self) -> builder::GetMigratedTokens<'_> {
        builder::GetMigratedTokens::new(self)
    }
    /**CONTROLLER.RANKING.NEW_TOKENS.SUMMARY

CONTROLLER.RANKING.NEW_TOKENS.DESCRIPTION

Sends a `GET` request to `/v1/ranking/{chain}/newTokens`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
- `exclude_keywords`: DTO.TOKEN.FILTER.EXCLUDE_KEYWORDS
- `filters`: DTO.TOKEN.FILTER.FILTERS
- `launchpad_platform`: DTO.TOKEN.FILTER.LAUNCHPAD_PLATFORM
- `range_filters`: DTO.TOKEN.REQUEST.FILTER_BY
- `search_keywords`: DTO.TOKEN.FILTER.SEARCH_KEYWORDS
- `sort_by`: DTO.TOKEN.REQUEST.SORT_BY
- `sort_direction`: DTO.TOKEN.REQUEST.SORT_DIRECTION
- `tag`: DTO.TOKEN.REQUEST.TAG
```ignore
let response = client.get_new_tokens()
    .chain(chain)
    .exclude_keywords(exclude_keywords)
    .filters(filters)
    .launchpad_platform(launchpad_platform)
    .range_filters(range_filters)
    .search_keywords(search_keywords)
    .sort_by(sort_by)
    .sort_direction(sort_direction)
    .tag(tag)
    .send()
    .await;
```*/
    pub fn get_new_tokens(&self) -> builder::GetNewTokens<'_> {
        builder::GetNewTokens::new(self)
    }
    /**CONTROLLER.RANKING.STOCKS_TOKENS.SUMMARY

CONTROLLER.RANKING.STOCKS_TOKENS.DESCRIPTION

Sends a `GET` request to `/v1/ranking/{chain}/stocks`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
- `exclude_keywords`: DTO.TOKEN.FILTER.EXCLUDE_KEYWORDS
- `filters`: DTO.TOKEN.FILTER.FILTERS
- `launchpad_platform`: DTO.TOKEN.FILTER.LAUNCHPAD_PLATFORM
- `range_filters`: DTO.TOKEN.REQUEST.FILTER_BY
- `search_keywords`: DTO.TOKEN.FILTER.SEARCH_KEYWORDS
- `sort_by`: DTO.TOKEN.REQUEST.SORT_BY
- `sort_direction`: DTO.TOKEN.REQUEST.SORT_DIRECTION
- `tag`: DTO.TOKEN.REQUEST.TAG
```ignore
let response = client.get_stocks_tokens()
    .chain(chain)
    .exclude_keywords(exclude_keywords)
    .filters(filters)
    .launchpad_platform(launchpad_platform)
    .range_filters(range_filters)
    .search_keywords(search_keywords)
    .sort_by(sort_by)
    .sort_direction(sort_direction)
    .tag(tag)
    .send()
    .await;
```*/
    pub fn get_stocks_tokens(&self) -> builder::GetStocksTokens<'_> {
        builder::GetStocksTokens::new(self)
    }
    /**CONTROLLER.RED_PACKET.GET_REDPACKETS.SUMMARY

CONTROLLER.RED_PACKET.GET_REDPACKETS.DESCRIPTION

Sends a `GET` request to `/v1/redpacket`

Arguments:
- `chain`: DTO.RED_PACKET.CHAIN
- `creator`: DTO.RED_PACKET.CREATOR
- `cursor`: DTO.RED_PACKET.CURSOR
- `direction`: DTO.RED_PACKET.DIRECTION
- `limit`: DTO.RED_PACKET.LIMIT
```ignore
let response = client.get_redpackets()
    .chain(chain)
    .creator(creator)
    .cursor(cursor)
    .direction(direction)
    .limit(limit)
    .send()
    .await;
```*/
    pub fn get_redpackets(&self) -> builder::GetRedpackets<'_> {
        builder::GetRedpackets::new(self)
    }
    /**CONTROLLER.RED_PACKET.GET_CLAIMS_BY_ADDRESS.SUMMARY

CONTROLLER.RED_PACKET.GET_CLAIMS_BY_ADDRESS.DESCRIPTION

Sends a `GET` request to `/v1/redpacket/wallet/{address}/claims`

Arguments:
- `address`
- `cursor`: DTO.RED_PACKET.CURSOR
- `direction`: DTO.RED_PACKET.DIRECTION
- `limit`: DTO.RED_PACKET.LIMIT
```ignore
let response = client.get_claims_by_address()
    .address(address)
    .cursor(cursor)
    .direction(direction)
    .limit(limit)
    .send()
    .await;
```*/
    pub fn get_claims_by_address(&self) -> builder::GetClaimsByAddress<'_> {
        builder::GetClaimsByAddress::new(self)
    }
    /**CONTROLLER.RED_PACKET.GET_REDPACKETS_BY_ADDRESS.SUMMARY

CONTROLLER.RED_PACKET.GET_REDPACKETS_BY_ADDRESS.DESCRIPTION

Sends a `GET` request to `/v1/redpacket/wallet/{address}/redpackets`

Arguments:
- `address`
- `cursor`: DTO.RED_PACKET.CURSOR
- `direction`: DTO.RED_PACKET.DIRECTION
- `limit`: DTO.RED_PACKET.LIMIT
```ignore
let response = client.get_redpackets_by_address()
    .address(address)
    .cursor(cursor)
    .direction(direction)
    .limit(limit)
    .send()
    .await;
```*/
    pub fn get_redpackets_by_address(&self) -> builder::GetRedpacketsByAddress<'_> {
        builder::GetRedpacketsByAddress::new(self)
    }
    /**CONTROLLER.RED_PACKET.CLAIM.SUMMARY

CONTROLLER.RED_PACKET.CLAIM.DESCRIPTION

Sends a `POST` request to `/v1/redpacket/{chain}/claim`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
- `body`
```ignore
let response = client.claim_redpacket()
    .chain(chain)
    .body(body)
    .send()
    .await;
```*/
    pub fn claim_redpacket(&self) -> builder::ClaimRedpacket<'_> {
        builder::ClaimRedpacket::new(self)
    }
    /**CONTROLLER.RED_PACKET.CREATE.SUMMARY

CONTROLLER.RED_PACKET.CREATE.DESCRIPTION

Sends a `POST` request to `/v1/redpacket/{chain}/create`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
- `body`
```ignore
let response = client.create_redpacket()
    .chain(chain)
    .body(body)
    .send()
    .await;
```*/
    pub fn create_redpacket(&self) -> builder::CreateRedpacket<'_> {
        builder::CreateRedpacket::new(self)
    }
    /**CONTROLLER.RED_PACKET.SEND.SUMMARY

CONTROLLER.RED_PACKET.SEND.DESCRIPTION

Sends a `POST` request to `/v1/redpacket/{chain}/send`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
- `body`
```ignore
let response = client.redpacket_send()
    .chain(chain)
    .body(body)
    .send()
    .await;
```*/
    pub fn redpacket_send(&self) -> builder::RedpacketSend<'_> {
        builder::RedpacketSend::new(self)
    }
    /**CONTROLLER.RED_PACKET.GET.SUMMARY

CONTROLLER.RED_PACKET.GET.DESCRIPTION

Sends a `GET` request to `/v1/redpacket/{id}`

Arguments:
- `id`: DTO.RED_PACKET.ID
```ignore
let response = client.get_redpacket()
    .id(id)
    .send()
    .await;
```*/
    pub fn get_redpacket(&self) -> builder::GetRedpacket<'_> {
        builder::GetRedpacket::new(self)
    }
    /**CONTROLLER.RED_PACKET.GET_CLAIMS.SUMMARY

CONTROLLER.RED_PACKET.GET_CLAIMS.DESCRIPTION

Sends a `GET` request to `/v1/redpacket/{id}/claims`

Arguments:
- `id`: DTO.RED_PACKET.ID
- `cursor`: DTO.RED_PACKET.CURSOR
- `direction`: DTO.RED_PACKET.DIRECTION
- `limit`: DTO.RED_PACKET.LIMIT
```ignore
let response = client.get_claims()
    .id(id)
    .cursor(cursor)
    .direction(direction)
    .limit(limit)
    .send()
    .await;
```*/
    pub fn get_claims(&self) -> builder::GetClaims<'_> {
        builder::GetClaims::new(self)
    }
    /**CONTROLLER.MOONSHOT.CREATE_TOKEN.SUMMARY

CONTROLLER.MOONSHOT.CREATE_TOKEN.DESCRIPTION

Sends a `POST` request to `/v1/sol/moonshot/create`

Arguments:
- `body`: Token creation parameters
```ignore
let response = client.moonshot_create_token()
    .body(body)
    .send()
    .await;
```*/
    pub fn moonshot_create_token(&self) -> builder::MoonshotCreateToken<'_> {
        builder::MoonshotCreateToken::new(self)
    }
    /**CONTROLLER.MOONSHOT.SUBMIT_CREATE_TOKEN.SUMMARY

CONTROLLER.MOONSHOT.SUBMIT_CREATE_TOKEN.DESCRIPTION

Sends a `POST` request to `/v1/sol/moonshot/submitCreateToken`

Arguments:
- `body`: Signed transaction and token details
```ignore
let response = client.moonshot_submit_create_token()
    .body(body)
    .send()
    .await;
```*/
    pub fn moonshot_submit_create_token(
        &self,
    ) -> builder::MoonshotSubmitCreateToken<'_> {
        builder::MoonshotSubmitCreateToken::new(self)
    }
    /**CONTROLLER.PUMPFUN.CREATE_TOKEN.SUMMARY

CONTROLLER.PUMPFUN.CREATE_TOKEN.DESCRIPTION

Sends a `POST` request to `/v1/sol/pumpfun/create`

Arguments:
- `body`: Required parameters for minting token
```ignore
let response = client.pumpfun_create_token()
    .body(body)
    .send()
    .await;
```*/
    pub fn pumpfun_create_token(&self) -> builder::PumpfunCreateToken<'_> {
        builder::PumpfunCreateToken::new(self)
    }
    /**CONTROLLER.TOKEN.SEARCH.SUMMARY

CONTROLLER.TOKEN.SEARCH.DESCRIPTION

Sends a `GET` request to `/v1/token/search`

Arguments:
- `chains`: DTO.TOKEN.SEARCH.CHAINS
- `cursor`: DTO.PAGE.CURSOR.DESCRIPTION
- `direction`: DTO.PAGE.DIRECTION
- `limit`: DTO.PAGE.LIMIT
- `protocols`: DTO.TOKEN.SEARCH.PROTOCOLS
- `q`: DTO.TOKEN.SEARCH.QUERY
- `sort`: DTO.TOKEN.SEARCH.SORT_DIRECTION
- `sort_by`: DTO.TOKEN.SEARCH.SORT_BY
```ignore
let response = client.search()
    .chains(chains)
    .cursor(cursor)
    .direction(direction)
    .limit(limit)
    .protocols(protocols)
    .q(q)
    .sort(sort)
    .sort_by(sort_by)
    .send()
    .await;
```*/
    pub fn search(&self) -> builder::Search<'_> {
        builder::Search::new(self)
    }
    /**CONTROLLER.TOKEN.GET_DEV_TOKENS.SUMMARY

CONTROLLER.TOKEN.GET_DEV_TOKENS.DESCRIPTION

Sends a `GET` request to `/v1/token/{chain}/dev/{devAddress}/tokens`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
- `dev_address`: Developer address
```ignore
let response = client.get_dev_tokens()
    .chain(chain)
    .dev_address(dev_address)
    .send()
    .await;
```*/
    pub fn get_dev_tokens(&self) -> builder::GetDevTokens<'_> {
        builder::GetDevTokens::new(self)
    }
    /**CONTROLLER.TOKEN.GET_TOKEN_LIST.SUMMARY

CONTROLLER.TOKEN.GET_TOKEN_LIST.DESCRIPTION

Sends a `GET` request to `/v1/token/{chain}/list`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
- `cursor`: DTO.PAGE.CURSOR.DESCRIPTION
- `direction`: DTO.PAGE.DIRECTION
- `limit`: DTO.PAGE.LIMIT
- `max_h1_buy_volume_in_usd`: DTO.TOKEN.LIST.QUERY.MAX_H1_BUY_VOLUME_IN_USD
- `max_h1_buyers`: DTO.TOKEN.LIST.QUERY.MAX_H1_BUYERS
- `max_h1_buys`: DTO.TOKEN.LIST.QUERY.MAX_H1_BUYS
- `max_h1_price_change_ratio`: DTO.TOKEN.LIST.QUERY.MAX_H1_PRICE_CHANGE_RATIO
- `max_h1_sell_volume_in_usd`: DTO.TOKEN.LIST.QUERY.MAX_H1_SELL_VOLUME_IN_USD
- `max_h1_sellers`: DTO.TOKEN.LIST.QUERY.MAX_H1_SELLERS
- `max_h1_sells`: DTO.TOKEN.LIST.QUERY.MAX_H1_SELLS
- `max_h1_trades`: DTO.TOKEN.LIST.QUERY.MAX_H1_TRADES
- `max_h1_volume_in_usd`: DTO.TOKEN.LIST.QUERY.MAX_H1_VOLUME_IN_USD
- `max_h24_buy_volume_in_usd`: DTO.TOKEN.LIST.QUERY.MAX_H24_BUY_VOLUME_IN_USD
- `max_h24_buyers`: DTO.TOKEN.LIST.QUERY.MAX_H24_BUYERS
- `max_h24_buys`: DTO.TOKEN.LIST.QUERY.MAX_H24_BUYS
- `max_h24_price_change_ratio`: DTO.TOKEN.LIST.QUERY.MAX_H24_PRICE_CHANGE_RATIO
- `max_h24_sell_volume_in_usd`: DTO.TOKEN.LIST.QUERY.MAX_H24_SELL_VOLUME_IN_USD
- `max_h24_sellers`: DTO.TOKEN.LIST.QUERY.MAX_H24_SELLERS
- `max_h24_sells`: DTO.TOKEN.LIST.QUERY.MAX_H24_SELLS
- `max_h24_trades`: DTO.TOKEN.LIST.QUERY.MAX_H24_TRADES
- `max_h24_volume_in_usd`: DTO.TOKEN.LIST.QUERY.MAX_H24_VOLUME_IN_USD
- `max_h4_buy_volume_in_usd`: DTO.TOKEN.LIST.QUERY.MAX_H4_BUY_VOLUME_IN_USD
- `max_h4_buyers`: DTO.TOKEN.LIST.QUERY.MAX_H4_BUYERS
- `max_h4_buys`: DTO.TOKEN.LIST.QUERY.MAX_H4_BUYS
- `max_h4_price_change_ratio`: DTO.TOKEN.LIST.QUERY.MAX_H4_PRICE_CHANGE_RATIO
- `max_h4_sell_volume_in_usd`: DTO.TOKEN.LIST.QUERY.MAX_H4_SELL_VOLUME_IN_USD
- `max_h4_sellers`: DTO.TOKEN.LIST.QUERY.MAX_H4_SELLERS
- `max_h4_sells`: DTO.TOKEN.LIST.QUERY.MAX_H4_SELLS
- `max_h4_trades`: DTO.TOKEN.LIST.QUERY.MAX_H4_TRADES
- `max_h4_volume_in_usd`: DTO.TOKEN.LIST.QUERY.MAX_H4_VOLUME_IN_USD
- `max_m15_buy_volume_in_usd`: DTO.TOKEN.LIST.QUERY.MAX_M15_BUY_VOLUME_IN_USD
- `max_m15_buyers`: DTO.TOKEN.LIST.QUERY.MAX_M15_BUYERS
- `max_m15_buys`: DTO.TOKEN.LIST.QUERY.MAX_M15_BUYS
- `max_m15_price_change_ratio`: DTO.TOKEN.LIST.QUERY.MAX_M15_PRICE_CHANGE_RATIO
- `max_m15_sell_volume_in_usd`: DTO.TOKEN.LIST.QUERY.MAX_M15_SELL_VOLUME_IN_USD
- `max_m15_sellers`: DTO.TOKEN.LIST.QUERY.MAX_M15_SELLERS
- `max_m15_sells`: DTO.TOKEN.LIST.QUERY.MAX_M15_SELLS
- `max_m15_trades`: DTO.TOKEN.LIST.QUERY.MAX_M15_TRADES
- `max_m15_volume_in_usd`: DTO.TOKEN.LIST.QUERY.MAX_M15_VOLUME_IN_USD
- `max_m1_buy_volume_in_usd`: DTO.TOKEN.LIST.QUERY.MAX_M1_BUY_VOLUME_IN_USD
- `max_m1_buyers`: DTO.TOKEN.LIST.QUERY.MAX_M1_BUYERS
- `max_m1_buys`: DTO.TOKEN.LIST.QUERY.MAX_M1_BUYS
- `max_m1_price_change_ratio`: DTO.TOKEN.LIST.QUERY.MAX_M1_PRICE_CHANGE_RATIO
- `max_m1_sell_volume_in_usd`: DTO.TOKEN.LIST.QUERY.MAX_M1_SELL_VOLUME_IN_USD
- `max_m1_sellers`: DTO.TOKEN.LIST.QUERY.MAX_M1_SELLERS
- `max_m1_sells`: DTO.TOKEN.LIST.QUERY.MAX_M1_SELLS
- `max_m1_trades`: DTO.TOKEN.LIST.QUERY.MAX_M1_TRADES
- `max_m1_volume_in_usd`: DTO.TOKEN.LIST.QUERY.MAX_M1_VOLUME_IN_USD
- `max_m30_buy_volume_in_usd`: DTO.TOKEN.LIST.QUERY.MAX_M30_BUY_VOLUME_IN_USD
- `max_m30_buyers`: DTO.TOKEN.LIST.QUERY.MAX_M30_BUYERS
- `max_m30_buys`: DTO.TOKEN.LIST.QUERY.MAX_M30_BUYS
- `max_m30_price_change_ratio`: DTO.TOKEN.LIST.QUERY.MAX_M30_PRICE_CHANGE_RATIO
- `max_m30_sell_volume_in_usd`: DTO.TOKEN.LIST.QUERY.MAX_M30_SELL_VOLUME_IN_USD
- `max_m30_sellers`: DTO.TOKEN.LIST.QUERY.MAX_M30_SELLERS
- `max_m30_sells`: DTO.TOKEN.LIST.QUERY.MAX_M30_SELLS
- `max_m30_trades`: DTO.TOKEN.LIST.QUERY.MAX_M30_TRADES
- `max_m30_volume_in_usd`: DTO.TOKEN.LIST.QUERY.MAX_M30_VOLUME_IN_USD
- `max_m5_buy_volume_in_usd`: DTO.TOKEN.LIST.QUERY.MAX_M5_BUY_VOLUME_IN_USD
- `max_m5_buyers`: DTO.TOKEN.LIST.QUERY.MAX_M5_BUYERS
- `max_m5_buys`: DTO.TOKEN.LIST.QUERY.MAX_M5_BUYS
- `max_m5_price_change_ratio`: DTO.TOKEN.LIST.QUERY.MAX_M5_PRICE_CHANGE_RATIO
- `max_m5_sell_volume_in_usd`: DTO.TOKEN.LIST.QUERY.MAX_M5_SELL_VOLUME_IN_USD
- `max_m5_sellers`: DTO.TOKEN.LIST.QUERY.MAX_M5_SELLERS
- `max_m5_sells`: DTO.TOKEN.LIST.QUERY.MAX_M5_SELLS
- `max_m5_trades`: DTO.TOKEN.LIST.QUERY.MAX_M5_TRADES
- `max_m5_volume_in_usd`: DTO.TOKEN.LIST.QUERY.MAX_M5_VOLUME_IN_USD
- `min_h1_buy_volume_in_usd`: DTO.TOKEN.LIST.QUERY.MIN_H1_BUY_VOLUME_IN_USD
- `min_h1_buyers`: DTO.TOKEN.LIST.QUERY.MIN_H1_BUYERS
- `min_h1_buys`: DTO.TOKEN.LIST.QUERY.MIN_H1_BUYS
- `min_h1_price_change_ratio`: DTO.TOKEN.LIST.QUERY.MIN_H1_PRICE_CHANGE_RATIO
- `min_h1_sell_volume_in_usd`: DTO.TOKEN.LIST.QUERY.MIN_H1_SELL_VOLUME_IN_USD
- `min_h1_sellers`: DTO.TOKEN.LIST.QUERY.MIN_H1_SELLERS
- `min_h1_sells`: DTO.TOKEN.LIST.QUERY.MIN_H1_SELLS
- `min_h1_trades`: DTO.TOKEN.LIST.QUERY.MIN_H1_TRADES
- `min_h1_volume_in_usd`: DTO.TOKEN.LIST.QUERY.MIN_H1_VOLUME_IN_USD
- `min_h24_buy_volume_in_usd`: DTO.TOKEN.LIST.QUERY.MIN_H24_BUY_VOLUME_IN_USD
- `min_h24_buyers`: DTO.TOKEN.LIST.QUERY.MIN_H24_BUYERS
- `min_h24_buys`: DTO.TOKEN.LIST.QUERY.MIN_H24_BUYS
- `min_h24_price_change_ratio`: DTO.TOKEN.LIST.QUERY.MIN_H24_PRICE_CHANGE_RATIO
- `min_h24_sell_volume_in_usd`: DTO.TOKEN.LIST.QUERY.MIN_H24_SELL_VOLUME_IN_USD
- `min_h24_sellers`: DTO.TOKEN.LIST.QUERY.MIN_H24_SELLERS
- `min_h24_sells`: DTO.TOKEN.LIST.QUERY.MIN_H24_SELLS
- `min_h24_trades`: DTO.TOKEN.LIST.QUERY.MIN_H24_TRADES
- `min_h24_volume_in_usd`: DTO.TOKEN.LIST.QUERY.MIN_H24_VOLUME_IN_USD
- `min_h4_buy_volume_in_usd`: DTO.TOKEN.LIST.QUERY.MIN_H4_BUY_VOLUME_IN_USD
- `min_h4_buyers`: DTO.TOKEN.LIST.QUERY.MIN_H4_BUYERS
- `min_h4_buys`: DTO.TOKEN.LIST.QUERY.MIN_H4_BUYS
- `min_h4_price_change_ratio`: DTO.TOKEN.LIST.QUERY.MIN_H4_PRICE_CHANGE_RATIO
- `min_h4_sell_volume_in_usd`: DTO.TOKEN.LIST.QUERY.MIN_H4_SELL_VOLUME_IN_USD
- `min_h4_sellers`: DTO.TOKEN.LIST.QUERY.MIN_H4_SELLERS
- `min_h4_sells`: DTO.TOKEN.LIST.QUERY.MIN_H4_SELLS
- `min_h4_trades`: DTO.TOKEN.LIST.QUERY.MIN_H4_TRADES
- `min_h4_volume_in_usd`: DTO.TOKEN.LIST.QUERY.MIN_H4_VOLUME_IN_USD
- `min_m15_buy_volume_in_usd`: DTO.TOKEN.LIST.QUERY.MIN_M15_BUY_VOLUME_IN_USD
- `min_m15_buyers`: DTO.TOKEN.LIST.QUERY.MIN_M15_BUYERS
- `min_m15_buys`: DTO.TOKEN.LIST.QUERY.MIN_M15_BUYS
- `min_m15_price_change_ratio`: DTO.TOKEN.LIST.QUERY.MIN_M15_PRICE_CHANGE_RATIO
- `min_m15_sell_volume_in_usd`: DTO.TOKEN.LIST.QUERY.MIN_M15_SELL_VOLUME_IN_USD
- `min_m15_sellers`: DTO.TOKEN.LIST.QUERY.MIN_M15_SELLERS
- `min_m15_sells`: DTO.TOKEN.LIST.QUERY.MIN_M15_SELLS
- `min_m15_trades`: DTO.TOKEN.LIST.QUERY.MIN_M15_TRADES
- `min_m15_volume_in_usd`: DTO.TOKEN.LIST.QUERY.MIN_M15_VOLUME_IN_USD
- `min_m1_buy_volume_in_usd`: DTO.TOKEN.LIST.QUERY.MIN_M1_BUY_VOLUME_IN_USD
- `min_m1_buyers`: DTO.TOKEN.LIST.QUERY.MIN_M1_BUYERS
- `min_m1_buys`: DTO.TOKEN.LIST.QUERY.MIN_M1_BUYS
- `min_m1_price_change_ratio`: DTO.TOKEN.LIST.QUERY.MIN_M1_PRICE_CHANGE_RATIO
- `min_m1_sell_volume_in_usd`: DTO.TOKEN.LIST.QUERY.MIN_M1_SELL_VOLUME_IN_USD
- `min_m1_sellers`: DTO.TOKEN.LIST.QUERY.MIN_M1_SELLERS
- `min_m1_sells`: DTO.TOKEN.LIST.QUERY.MIN_M1_SELLS
- `min_m1_trades`: DTO.TOKEN.LIST.QUERY.MIN_M1_TRADES
- `min_m1_volume_in_usd`: DTO.TOKEN.LIST.QUERY.MIN_M1_VOLUME_IN_USD
- `min_m30_buy_volume_in_usd`: DTO.TOKEN.LIST.QUERY.MIN_M30_BUY_VOLUME_IN_USD
- `min_m30_buyers`: DTO.TOKEN.LIST.QUERY.MIN_M30_BUYERS
- `min_m30_buys`: DTO.TOKEN.LIST.QUERY.MIN_M30_BUYS
- `min_m30_price_change_ratio`: DTO.TOKEN.LIST.QUERY.MIN_M30_PRICE_CHANGE_RATIO
- `min_m30_sell_volume_in_usd`: DTO.TOKEN.LIST.QUERY.MIN_M30_SELL_VOLUME_IN_USD
- `min_m30_sellers`: DTO.TOKEN.LIST.QUERY.MIN_M30_SELLERS
- `min_m30_sells`: DTO.TOKEN.LIST.QUERY.MIN_M30_SELLS
- `min_m30_trades`: DTO.TOKEN.LIST.QUERY.MIN_M30_TRADES
- `min_m30_volume_in_usd`: DTO.TOKEN.LIST.QUERY.MIN_M30_VOLUME_IN_USD
- `min_m5_buy_volume_in_usd`: DTO.TOKEN.LIST.QUERY.MIN_M5_BUY_VOLUME_IN_USD
- `min_m5_buyers`: DTO.TOKEN.LIST.QUERY.MIN_M5_BUYERS
- `min_m5_buys`: DTO.TOKEN.LIST.QUERY.MIN_M5_BUYS
- `min_m5_price_change_ratio`: DTO.TOKEN.LIST.QUERY.MIN_M5_PRICE_CHANGE_RATIO
- `min_m5_sell_volume_in_usd`: DTO.TOKEN.LIST.QUERY.MIN_M5_SELL_VOLUME_IN_USD
- `min_m5_sellers`: DTO.TOKEN.LIST.QUERY.MIN_M5_SELLERS
- `min_m5_sells`: DTO.TOKEN.LIST.QUERY.MIN_M5_SELLS
- `min_m5_trades`: DTO.TOKEN.LIST.QUERY.MIN_M5_TRADES
- `min_m5_volume_in_usd`: DTO.TOKEN.LIST.QUERY.MIN_M5_VOLUME_IN_USD
- `sort`: DTO.TOKEN.SEARCH.SORT_DIRECTION
- `sort_by`: DTO.TOKEN.LIST.QUERY.SORT_BY
```ignore
let response = client.list_token()
    .chain(chain)
    .cursor(cursor)
    .direction(direction)
    .limit(limit)
    .max_h1_buy_volume_in_usd(max_h1_buy_volume_in_usd)
    .max_h1_buyers(max_h1_buyers)
    .max_h1_buys(max_h1_buys)
    .max_h1_price_change_ratio(max_h1_price_change_ratio)
    .max_h1_sell_volume_in_usd(max_h1_sell_volume_in_usd)
    .max_h1_sellers(max_h1_sellers)
    .max_h1_sells(max_h1_sells)
    .max_h1_trades(max_h1_trades)
    .max_h1_volume_in_usd(max_h1_volume_in_usd)
    .max_h24_buy_volume_in_usd(max_h24_buy_volume_in_usd)
    .max_h24_buyers(max_h24_buyers)
    .max_h24_buys(max_h24_buys)
    .max_h24_price_change_ratio(max_h24_price_change_ratio)
    .max_h24_sell_volume_in_usd(max_h24_sell_volume_in_usd)
    .max_h24_sellers(max_h24_sellers)
    .max_h24_sells(max_h24_sells)
    .max_h24_trades(max_h24_trades)
    .max_h24_volume_in_usd(max_h24_volume_in_usd)
    .max_h4_buy_volume_in_usd(max_h4_buy_volume_in_usd)
    .max_h4_buyers(max_h4_buyers)
    .max_h4_buys(max_h4_buys)
    .max_h4_price_change_ratio(max_h4_price_change_ratio)
    .max_h4_sell_volume_in_usd(max_h4_sell_volume_in_usd)
    .max_h4_sellers(max_h4_sellers)
    .max_h4_sells(max_h4_sells)
    .max_h4_trades(max_h4_trades)
    .max_h4_volume_in_usd(max_h4_volume_in_usd)
    .max_m15_buy_volume_in_usd(max_m15_buy_volume_in_usd)
    .max_m15_buyers(max_m15_buyers)
    .max_m15_buys(max_m15_buys)
    .max_m15_price_change_ratio(max_m15_price_change_ratio)
    .max_m15_sell_volume_in_usd(max_m15_sell_volume_in_usd)
    .max_m15_sellers(max_m15_sellers)
    .max_m15_sells(max_m15_sells)
    .max_m15_trades(max_m15_trades)
    .max_m15_volume_in_usd(max_m15_volume_in_usd)
    .max_m1_buy_volume_in_usd(max_m1_buy_volume_in_usd)
    .max_m1_buyers(max_m1_buyers)
    .max_m1_buys(max_m1_buys)
    .max_m1_price_change_ratio(max_m1_price_change_ratio)
    .max_m1_sell_volume_in_usd(max_m1_sell_volume_in_usd)
    .max_m1_sellers(max_m1_sellers)
    .max_m1_sells(max_m1_sells)
    .max_m1_trades(max_m1_trades)
    .max_m1_volume_in_usd(max_m1_volume_in_usd)
    .max_m30_buy_volume_in_usd(max_m30_buy_volume_in_usd)
    .max_m30_buyers(max_m30_buyers)
    .max_m30_buys(max_m30_buys)
    .max_m30_price_change_ratio(max_m30_price_change_ratio)
    .max_m30_sell_volume_in_usd(max_m30_sell_volume_in_usd)
    .max_m30_sellers(max_m30_sellers)
    .max_m30_sells(max_m30_sells)
    .max_m30_trades(max_m30_trades)
    .max_m30_volume_in_usd(max_m30_volume_in_usd)
    .max_m5_buy_volume_in_usd(max_m5_buy_volume_in_usd)
    .max_m5_buyers(max_m5_buyers)
    .max_m5_buys(max_m5_buys)
    .max_m5_price_change_ratio(max_m5_price_change_ratio)
    .max_m5_sell_volume_in_usd(max_m5_sell_volume_in_usd)
    .max_m5_sellers(max_m5_sellers)
    .max_m5_sells(max_m5_sells)
    .max_m5_trades(max_m5_trades)
    .max_m5_volume_in_usd(max_m5_volume_in_usd)
    .min_h1_buy_volume_in_usd(min_h1_buy_volume_in_usd)
    .min_h1_buyers(min_h1_buyers)
    .min_h1_buys(min_h1_buys)
    .min_h1_price_change_ratio(min_h1_price_change_ratio)
    .min_h1_sell_volume_in_usd(min_h1_sell_volume_in_usd)
    .min_h1_sellers(min_h1_sellers)
    .min_h1_sells(min_h1_sells)
    .min_h1_trades(min_h1_trades)
    .min_h1_volume_in_usd(min_h1_volume_in_usd)
    .min_h24_buy_volume_in_usd(min_h24_buy_volume_in_usd)
    .min_h24_buyers(min_h24_buyers)
    .min_h24_buys(min_h24_buys)
    .min_h24_price_change_ratio(min_h24_price_change_ratio)
    .min_h24_sell_volume_in_usd(min_h24_sell_volume_in_usd)
    .min_h24_sellers(min_h24_sellers)
    .min_h24_sells(min_h24_sells)
    .min_h24_trades(min_h24_trades)
    .min_h24_volume_in_usd(min_h24_volume_in_usd)
    .min_h4_buy_volume_in_usd(min_h4_buy_volume_in_usd)
    .min_h4_buyers(min_h4_buyers)
    .min_h4_buys(min_h4_buys)
    .min_h4_price_change_ratio(min_h4_price_change_ratio)
    .min_h4_sell_volume_in_usd(min_h4_sell_volume_in_usd)
    .min_h4_sellers(min_h4_sellers)
    .min_h4_sells(min_h4_sells)
    .min_h4_trades(min_h4_trades)
    .min_h4_volume_in_usd(min_h4_volume_in_usd)
    .min_m15_buy_volume_in_usd(min_m15_buy_volume_in_usd)
    .min_m15_buyers(min_m15_buyers)
    .min_m15_buys(min_m15_buys)
    .min_m15_price_change_ratio(min_m15_price_change_ratio)
    .min_m15_sell_volume_in_usd(min_m15_sell_volume_in_usd)
    .min_m15_sellers(min_m15_sellers)
    .min_m15_sells(min_m15_sells)
    .min_m15_trades(min_m15_trades)
    .min_m15_volume_in_usd(min_m15_volume_in_usd)
    .min_m1_buy_volume_in_usd(min_m1_buy_volume_in_usd)
    .min_m1_buyers(min_m1_buyers)
    .min_m1_buys(min_m1_buys)
    .min_m1_price_change_ratio(min_m1_price_change_ratio)
    .min_m1_sell_volume_in_usd(min_m1_sell_volume_in_usd)
    .min_m1_sellers(min_m1_sellers)
    .min_m1_sells(min_m1_sells)
    .min_m1_trades(min_m1_trades)
    .min_m1_volume_in_usd(min_m1_volume_in_usd)
    .min_m30_buy_volume_in_usd(min_m30_buy_volume_in_usd)
    .min_m30_buyers(min_m30_buyers)
    .min_m30_buys(min_m30_buys)
    .min_m30_price_change_ratio(min_m30_price_change_ratio)
    .min_m30_sell_volume_in_usd(min_m30_sell_volume_in_usd)
    .min_m30_sellers(min_m30_sellers)
    .min_m30_sells(min_m30_sells)
    .min_m30_trades(min_m30_trades)
    .min_m30_volume_in_usd(min_m30_volume_in_usd)
    .min_m5_buy_volume_in_usd(min_m5_buy_volume_in_usd)
    .min_m5_buyers(min_m5_buyers)
    .min_m5_buys(min_m5_buys)
    .min_m5_price_change_ratio(min_m5_price_change_ratio)
    .min_m5_sell_volume_in_usd(min_m5_sell_volume_in_usd)
    .min_m5_sellers(min_m5_sellers)
    .min_m5_sells(min_m5_sells)
    .min_m5_trades(min_m5_trades)
    .min_m5_volume_in_usd(min_m5_volume_in_usd)
    .sort(sort)
    .sort_by(sort_by)
    .send()
    .await;
```*/
    pub fn list_token(&self) -> builder::ListToken<'_> {
        builder::ListToken::new(self)
    }
    /**CONTROLLER.TOKEN.GET_MARKET_DATA_MULTI.SUMMARY

CONTROLLER.TOKEN.GET_MARKET_DATA_MULTI.DESCRIPTION

Sends a `GET` request to `/v1/token/{chain}/marketData/multi`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
- `token_addresses`: GLOBAL.TOKENADDRESSES.DESCRIPTION
```ignore
let response = client.get_market_data_multi()
    .chain(chain)
    .token_addresses(token_addresses)
    .send()
    .await;
```*/
    pub fn get_market_data_multi(&self) -> builder::GetMarketDataMulti<'_> {
        builder::GetMarketDataMulti::new(self)
    }
    /**CONTROLLER.TOKEN.GET_METADATA_MULTI.SUMMARY

CONTROLLER.TOKEN.GET_METADATA_MULTI.DESCRIPTION

Sends a `GET` request to `/v1/token/{chain}/metadata/multi`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
- `token_addresses`: GLOBAL.TOKENADDRESSES.DESCRIPTION
```ignore
let response = client.get_metadata_multi()
    .chain(chain)
    .token_addresses(token_addresses)
    .send()
    .await;
```*/
    pub fn get_metadata_multi(&self) -> builder::GetMetadataMulti<'_> {
        builder::GetMetadataMulti::new(self)
    }
    /**CONTROLLER.TOKEN.GET_TOKENS.SUMMARY

CONTROLLER.TOKEN.GET_TOKENS.DESCRIPTION

Sends a `GET` request to `/v1/token/{chain}/multi`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
- `filter_by`: DTO.TOKEN.REQUEST.FILTER_BY
- `sort_by`: DTO.TOKEN.REQUEST.SORT_BY
- `sort_direction`: DTO.TOKEN.REQUEST.SORT_DIRECTION
- `token_addresses`: GLOBAL.TOKENADDRESSES.DESCRIPTION
```ignore
let response = client.get_tokens()
    .chain(chain)
    .filter_by(filter_by)
    .sort_by(sort_by)
    .sort_direction(sort_direction)
    .token_addresses(token_addresses)
    .send()
    .await;
```*/
    pub fn get_tokens(&self) -> builder::GetTokens<'_> {
        builder::GetTokens::new(self)
    }
    /**CONTROLLER.TOKEN.GET_PAIR_CANDLES.SUMMARY

CONTROLLER.TOKEN.GET_PAIR_CANDLES.DESCRIPTION

Sends a `GET` request to `/v1/token/{chain}/pair/{pair}/candles`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
- `pair`: GLOBAL.PAIR.DESCRIPTION
- `from`: DTO.CANDLE.FROM
- `limit`: DTO.CANDLE.LIMIT
- `price_type`: DTO.CANDLE.PRICE_TYPE
- `resolution`: DTO.CANDLE.RESOLUTION
- `to`: DTO.CANDLE.TO
```ignore
let response = client.get_pair_candles()
    .chain(chain)
    .pair(pair)
    .from(from)
    .limit(limit)
    .price_type(price_type)
    .resolution(resolution)
    .to(to)
    .send()
    .await;
```*/
    pub fn get_pair_candles(&self) -> builder::GetPairCandles<'_> {
        builder::GetPairCandles::new(self)
    }
    /**CONTROLLER.TOKEN.GET_POOL_CANDLES.SUMMARY

CONTROLLER.TOKEN.GET_POOL_CANDLES.DESCRIPTION

Sends a `GET` request to `/v1/token/{chain}/pool/{poolAddress}/candles`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
- `pool_address`: GLOBAL.POOLADDRESS.DESCRIPTION
- `from`: DTO.CANDLE.FROM
- `limit`: DTO.CANDLE.LIMIT
- `price_type`: DTO.CANDLE.PRICE_TYPE
- `resolution`: DTO.CANDLE.RESOLUTION
- `to`: DTO.CANDLE.TO
```ignore
let response = client.get_pool_candles()
    .chain(chain)
    .pool_address(pool_address)
    .from(from)
    .limit(limit)
    .price_type(price_type)
    .resolution(resolution)
    .to(to)
    .send()
    .await;
```*/
    pub fn get_pool_candles(&self) -> builder::GetPoolCandles<'_> {
        builder::GetPoolCandles::new(self)
    }
    /**CONTROLLER.TOKEN.GET_STATS_MULTI.SUMMARY

CONTROLLER.TOKEN.GET_STATS_MULTI.DESCRIPTION

Sends a `GET` request to `/v1/token/{chain}/stats/multi`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
- `token_addresses`: GLOBAL.TOKENADDRESSES.DESCRIPTION
```ignore
let response = client.get_stats_multi()
    .chain(chain)
    .token_addresses(token_addresses)
    .send()
    .await;
```*/
    pub fn get_stats_multi(&self) -> builder::GetStatsMulti<'_> {
        builder::GetStatsMulti::new(self)
    }
    /**CONTROLLER.TOKEN.GET.SUMMARY

CONTROLLER.TOKEN.GET.DESCRIPTION

Sends a `GET` request to `/v1/token/{chain}/{tokenAddress}`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
- `token_address`: GLOBAL.TOKENADDRESS.DESCRIPTION
```ignore
let response = client.get_token()
    .chain(chain)
    .token_address(token_address)
    .send()
    .await;
```*/
    pub fn get_token(&self) -> builder::GetToken<'_> {
        builder::GetToken::new(self)
    }
    /**CONTROLLER.TOKEN.GET_CANDLES.SUMMARY

CONTROLLER.TOKEN.GET_CANDLES.DESCRIPTION

Sends a `GET` request to `/v1/token/{chain}/{tokenAddress}/candles`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
- `token_address`: GLOBAL.TOKENADDRESS.DESCRIPTION
- `from`: DTO.CANDLE.FROM
- `limit`: DTO.CANDLE.LIMIT
- `price_type`: DTO.CANDLE.PRICE_TYPE
- `resolution`: DTO.CANDLE.RESOLUTION
- `to`: DTO.CANDLE.TO
```ignore
let response = client.get_candles()
    .chain(chain)
    .token_address(token_address)
    .from(from)
    .limit(limit)
    .price_type(price_type)
    .resolution(resolution)
    .to(to)
    .send()
    .await;
```*/
    pub fn get_candles(&self) -> builder::GetCandles<'_> {
        builder::GetCandles::new(self)
    }
    /**CONTROLLER.TOKEN.GET_CREATION.SUMMARY

CONTROLLER.TOKEN.GET_CREATION.DESCRIPTION

Sends a `GET` request to `/v1/token/{chain}/{tokenAddress}/creation`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
- `token_address`: GLOBAL.TOKENADDRESS.DESCRIPTION
```ignore
let response = client.get_creation()
    .chain(chain)
    .token_address(token_address)
    .send()
    .await;
```*/
    pub fn get_creation(&self) -> builder::GetCreation<'_> {
        builder::GetCreation::new(self)
    }
    /**CONTROLLER.TOKEN.GET_HOLDERS.SUMMARY

CONTROLLER.TOKEN.GET_HOLDERS.DESCRIPTION

Sends a `GET` request to `/v1/token/{chain}/{tokenAddress}/holders`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
- `token_address`: GLOBAL.TOKENADDRESS.DESCRIPTION
- `cursor`: DTO.PAGE.CURSOR.DESCRIPTION
- `direction`: DTO.PAGE.DIRECTION
- `limit`: DTO.PAGE.LIMIT
```ignore
let response = client.get_holders()
    .chain(chain)
    .token_address(token_address)
    .cursor(cursor)
    .direction(direction)
    .limit(limit)
    .send()
    .await;
```*/
    pub fn get_holders(&self) -> builder::GetHolders<'_> {
        builder::GetHolders::new(self)
    }
    /**CONTROLLER.TOKEN.GET_HOLDERS_MULTI.SUMMARY

CONTROLLER.TOKEN.GET_HOLDERS_MULTI.DESCRIPTION

Sends a `GET` request to `/v1/token/{chain}/{tokenAddress}/holders/multi`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
- `token_address`: GLOBAL.TOKENADDRESS.DESCRIPTION
- `wallet_addresses`: GLOBAL.WALLETADDRESSES.DESCRIPTION
```ignore
let response = client.get_holders_multi()
    .chain(chain)
    .token_address(token_address)
    .wallet_addresses(wallet_addresses)
    .send()
    .await;
```*/
    pub fn get_holders_multi(&self) -> builder::GetHoldersMulti<'_> {
        builder::GetHoldersMulti::new(self)
    }
    /**CONTROLLER.TOKEN.GET_LIQUIDITY_SNAPSHOTS.SUMMARY

CONTROLLER.TOKEN.GET_LIQUIDITY_SNAPSHOTS.DESCRIPTION

Sends a `GET` request to `/v1/token/{chain}/{tokenAddress}/liquiditySnapshots`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
- `token_address`: GLOBAL.TOKENADDRESS.DESCRIPTION
- `cursor`: DTO.PAGE.CURSOR.DESCRIPTION
- `direction`: DTO.PAGE.DIRECTION
- `limit`: DTO.PAGE.LIMIT
- `time`: DTO.TOKEN.LIQUIDITY_SNAPSHOT.TIME
```ignore
let response = client.get_token_liquidity_snapshots()
    .chain(chain)
    .token_address(token_address)
    .cursor(cursor)
    .direction(direction)
    .limit(limit)
    .time(time)
    .send()
    .await;
```*/
    pub fn get_token_liquidity_snapshots(
        &self,
    ) -> builder::GetTokenLiquiditySnapshots<'_> {
        builder::GetTokenLiquiditySnapshots::new(self)
    }
    /**CONTROLLER.TOKEN.GET_MARKET_CAP.SUMMARY

CONTROLLER.TOKEN.GET_MARKET_CAP.DESCRIPTION

Sends a `GET` request to `/v1/token/{chain}/{tokenAddress}/marketData`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
- `token_address`: GLOBAL.TOKENADDRESS.DESCRIPTION
```ignore
let response = client.get_market_data()
    .chain(chain)
    .token_address(token_address)
    .send()
    .await;
```*/
    pub fn get_market_data(&self) -> builder::GetMarketData<'_> {
        builder::GetMarketData::new(self)
    }
    /**CONTROLLER.TOKEN.GET_METADATA.SUMMARY

CONTROLLER.TOKEN.GET_METADATA.DESCRIPTION

Sends a `GET` request to `/v1/token/{chain}/{tokenAddress}/metadata`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
- `token_address`: GLOBAL.TOKENADDRESS.DESCRIPTION
```ignore
let response = client.get_metadata()
    .chain(chain)
    .token_address(token_address)
    .send()
    .await;
```*/
    pub fn get_metadata(&self) -> builder::GetMetadata<'_> {
        builder::GetMetadata::new(self)
    }
    /**CONTROLLER.TOKEN.GET_MINT_AND_BURN.SUMMARY

CONTROLLER.TOKEN.GET_MINT_AND_BURN.DESCRIPTION

Sends a `GET` request to `/v1/token/{chain}/{tokenAddress}/mintAndBurn`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
- `token_address`: GLOBAL.TOKENADDRESS.DESCRIPTION
- `cursor`: DTO.PAGE.CURSOR.DESCRIPTION
- `direction`: DTO.PAGE.DIRECTION
- `limit`: DTO.PAGE.LIMIT
- `type_`: DTO.TOKEN.MINT_AND_BURN.TYPE
```ignore
let response = client.get_mint_and_burn()
    .chain(chain)
    .token_address(token_address)
    .cursor(cursor)
    .direction(direction)
    .limit(limit)
    .type_(type_)
    .send()
    .await;
```*/
    pub fn get_mint_and_burn(&self) -> builder::GetMintAndBurn<'_> {
        builder::GetMintAndBurn::new(self)
    }
    /**CONTROLLER.TOKEN.GET_POOLS.SUMMARY

CONTROLLER.TOKEN.GET_POOLS.DESCRIPTION

Sends a `GET` request to `/v1/token/{chain}/{tokenAddress}/pools`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
- `token_address`: GLOBAL.TOKENADDRESS.DESCRIPTION
- `cursor`: DTO.PAGE.CURSOR.DESCRIPTION
- `direction`: DTO.PAGE.DIRECTION
- `limit`: DTO.PAGE.LIMIT
- `max_tvl_in_sol`: DTO.POOL.MAX_TVL_IN_SOL
- `max_tvl_in_usd`: DTO.POOL.MAX_TVL_IN_USD
- `min_tvl_in_sol`: DTO.POOL.MIN_TVL_IN_SOL
- `min_tvl_in_usd`: DTO.POOL.MIN_TVL_IN_USD
- `sort_by`: DTO.POOL.SORT_BY
- `sort_direction`: DTO.POOL.SORT_DIRECTION
```ignore
let response = client.get_pools()
    .chain(chain)
    .token_address(token_address)
    .cursor(cursor)
    .direction(direction)
    .limit(limit)
    .max_tvl_in_sol(max_tvl_in_sol)
    .max_tvl_in_usd(max_tvl_in_usd)
    .min_tvl_in_sol(min_tvl_in_sol)
    .min_tvl_in_usd(min_tvl_in_usd)
    .sort_by(sort_by)
    .sort_direction(sort_direction)
    .send()
    .await;
```*/
    pub fn get_pools(&self) -> builder::GetPools<'_> {
        builder::GetPools::new(self)
    }
    /**CONTROLLER.TOKEN.GET_PRICE_BY_TIME.SUMMARY

CONTROLLER.TOKEN.GET_PRICE_BY_TIME.DESCRIPTION

Sends a `GET` request to `/v1/token/{chain}/{tokenAddress}/price`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
- `token_address`: GLOBAL.TOKENADDRESS.DESCRIPTION
- `timestamp`: DTO.TOKEN.PRICE.QUERY.TIMESTAMP
```ignore
let response = client.get_price_by_time()
    .chain(chain)
    .token_address(token_address)
    .timestamp(timestamp)
    .send()
    .await;
```*/
    pub fn get_price_by_time(&self) -> builder::GetPriceByTime<'_> {
        builder::GetPriceByTime::new(self)
    }
    /**CONTROLLER.TOKEN.GET_PRICES.SUMMARY

CONTROLLER.TOKEN.GET_PRICES.DESCRIPTION

Sends a `GET` request to `/v1/token/{chain}/{tokenAddress}/prices`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
- `token_address`: GLOBAL.TOKENADDRESS.DESCRIPTION
- `cursor`: DTO.PAGE.CURSOR.DESCRIPTION
- `direction`: DTO.PAGE.DIRECTION
- `limit`: DTO.PAGE.LIMIT
```ignore
let response = client.get_prices()
    .chain(chain)
    .token_address(token_address)
    .cursor(cursor)
    .direction(direction)
    .limit(limit)
    .send()
    .await;
```*/
    pub fn get_prices(&self) -> builder::GetPrices<'_> {
        builder::GetPrices::new(self)
    }
    /**CONTROLLER.TOKEN.GET_SECURITY.SUMMARY

CONTROLLER.TOKEN.GET_SECURITY.DESCRIPTION

Sends a `GET` request to `/v1/token/{chain}/{tokenAddress}/security`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
- `token_address`: GLOBAL.TOKENADDRESS.DESCRIPTION
```ignore
let response = client.get_security()
    .chain(chain)
    .token_address(token_address)
    .send()
    .await;
```*/
    pub fn get_security(&self) -> builder::GetSecurity<'_> {
        builder::GetSecurity::new(self)
    }
    /**CONTROLLER.TOKEN.GET_STATS.SUMMARY

CONTROLLER.TOKEN.GET_STATS.DESCRIPTION

Sends a `GET` request to `/v1/token/{chain}/{tokenAddress}/stats`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
- `token_address`: GLOBAL.TOKENADDRESS.DESCRIPTION
```ignore
let response = client.get_stats()
    .chain(chain)
    .token_address(token_address)
    .send()
    .await;
```*/
    pub fn get_stats(&self) -> builder::GetStats<'_> {
        builder::GetStats::new(self)
    }
    /**CONTROLLER.TOKEN.GET_TOP_HOLDERS.SUMMARY

CONTROLLER.TOKEN.GET_TOP_HOLDERS.DESCRIPTION

Sends a `GET` request to `/v1/token/{chain}/{tokenAddress}/topHolders`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
- `token_address`: GLOBAL.TOKENADDRESS.DESCRIPTION
```ignore
let response = client.get_top_holders()
    .chain(chain)
    .token_address(token_address)
    .send()
    .await;
```*/
    pub fn get_top_holders(&self) -> builder::GetTopHolders<'_> {
        builder::GetTopHolders::new(self)
    }
    /**CONTROLLER.TOKEN.GET_TOKEN_TRADERS.SUMMARY

CONTROLLER.TOKEN.GET_TOKEN_TRADERS.DESCRIPTION

Sends a `GET` request to `/v1/token/{chain}/{tokenAddress}/traders/{tag}`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
- `token_address`: GLOBAL.TOKENADDRESS.DESCRIPTION
- `tag`: Token trader tag
```ignore
let response = client.get_token_traders()
    .chain(chain)
    .token_address(token_address)
    .tag(tag)
    .send()
    .await;
```*/
    pub fn get_token_traders(&self) -> builder::GetTokenTraders<'_> {
        builder::GetTokenTraders::new(self)
    }
    /**CONTROLLER.TOKEN.GET_TRANSFER_TOTAL.SUMMARY

CONTROLLER.TOKEN.GET_TRANSFER_TOTAL.DESCRIPTION

Sends a `GET` request to `/v1/token/{chain}/{tokenAddress}/transfer-total`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
- `token_address`: GLOBAL.TOKENADDRESS.DESCRIPTION
- `after_timestamp`: DTO.TOKEN.TRANSFER.QUERY.AFTER_TIMESTAMP
- `before_timestamp`: DTO.TOKEN.TRANSFER.QUERY.BEFORE_TIMESTAMP
- `cursor`: DTO.PAGE.CURSOR.DESCRIPTION
- `direction`: DTO.PAGE.DIRECTION
- `limit`: DTO.PAGE.LIMIT
```ignore
let response = client.get_token_transfer_total()
    .chain(chain)
    .token_address(token_address)
    .after_timestamp(after_timestamp)
    .before_timestamp(before_timestamp)
    .cursor(cursor)
    .direction(direction)
    .limit(limit)
    .send()
    .await;
```*/
    pub fn get_token_transfer_total(&self) -> builder::GetTokenTransferTotal<'_> {
        builder::GetTokenTransferTotal::new(self)
    }
    /**CONTROLLER.TOKEN.GET_TRANSFER_LIST.SUMMARY

CONTROLLER.TOKEN.GET_TRANSFER_LIST.DESCRIPTION

Sends a `GET` request to `/v1/token/{chain}/{tokenAddress}/transfers`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
- `token_address`: GLOBAL.TOKENADDRESS.DESCRIPTION
- `after_timestamp`: DTO.TOKEN.TRANSFER.QUERY.AFTER_TIMESTAMP
- `before_timestamp`: DTO.TOKEN.TRANSFER.QUERY.BEFORE_TIMESTAMP
- `cursor`: DTO.PAGE.CURSOR.DESCRIPTION
- `direction`: DTO.PAGE.DIRECTION
- `limit`: DTO.PAGE.LIMIT
```ignore
let response = client.get_token_transfers()
    .chain(chain)
    .token_address(token_address)
    .after_timestamp(after_timestamp)
    .before_timestamp(before_timestamp)
    .cursor(cursor)
    .direction(direction)
    .limit(limit)
    .send()
    .await;
```*/
    pub fn get_token_transfers(&self) -> builder::GetTokenTransfers<'_> {
        builder::GetTokenTransfers::new(self)
    }
    /**CONTROLLER.TRADE.GET.TOKEN.SUMMARY

CONTROLLER.TRADE.GET.TOKEN.DESCRIPTION

Sends a `GET` request to `/v1/trade/{chain}`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
- `after_block_height`: DTO.TRADE.QUERY.AFTER_BLOCK_HEIGHT
- `after_timestamp`: DTO.TRADE.QUERY.AFTER_TIMESTAMP
- `before_block_height`: DTO.TRADE.QUERY.BEFORE_BLOCK_HEIGHT
- `before_timestamp`: DTO.TRADE.QUERY.BEFORE_TIMESTAMP
- `cursor`: DTO.PAGE.CURSOR.DESCRIPTION
- `direction`: DTO.PAGE.DIRECTION
- `limit`: DTO.PAGE.LIMIT
- `pool_address`: DTO.TRADE.QUERY.POOL_ADDRESS
- `token_address`: DTO.TRADE.QUERY.TOKEN_ADDRESS
- `transactions_signature`: DTO.TRADE.QUERY.TRANSACTIONS_SIGNATURE
- `type_`: DTO.TRADE.QUERY.TRADES_TYPE
- `wallet_address`: DTO.TRADE.QUERY.WALLET_ADDRESS
```ignore
let response = client.get_trades()
    .chain(chain)
    .after_block_height(after_block_height)
    .after_timestamp(after_timestamp)
    .before_block_height(before_block_height)
    .before_timestamp(before_timestamp)
    .cursor(cursor)
    .direction(direction)
    .limit(limit)
    .pool_address(pool_address)
    .token_address(token_address)
    .transactions_signature(transactions_signature)
    .type_(type_)
    .wallet_address(wallet_address)
    .send()
    .await;
```*/
    pub fn get_trades(&self) -> builder::GetTrades<'_> {
        builder::GetTrades::new(self)
    }
    /**CONTROLLER.TRADE.GET.TOKEN_ACTIVITIES.SUMMARY

CONTROLLER.TRADE.GET.TOKEN_ACTIVITIES.DESCRIPTION

Sends a `GET` request to `/v1/trade/{chain}/activities`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
- `after_block_height`: DTO.TRADE.QUERY.AFTER_BLOCK_HEIGHT
- `after_timestamp`: DTO.TRADE.QUERY.AFTER_TIMESTAMP
- `before_block_height`: DTO.TRADE.QUERY.BEFORE_BLOCK_HEIGHT
- `before_timestamp`: DTO.TRADE.QUERY.BEFORE_TIMESTAMP
- `cursor`: DTO.PAGE.CURSOR.DESCRIPTION
- `direction`: DTO.PAGE.DIRECTION
- `limit`: DTO.PAGE.LIMIT
- `pool_address`: DTO.TRADE.QUERY.POOL_ADDRESS
- `token_address`: DTO.TRADE.QUERY.TOKEN_ADDRESS
- `transactions_signature`: DTO.TRADE.QUERY.TRANSACTIONS_SIGNATURE
- `type_`: DTO.TRADE.QUERY.ACTIVITIES_TYPE
- `wallet_address`: DTO.TRADE.QUERY.WALLET_ADDRESS
```ignore
let response = client.get_activities()
    .chain(chain)
    .after_block_height(after_block_height)
    .after_timestamp(after_timestamp)
    .before_block_height(before_block_height)
    .before_timestamp(before_timestamp)
    .cursor(cursor)
    .direction(direction)
    .limit(limit)
    .pool_address(pool_address)
    .token_address(token_address)
    .transactions_signature(transactions_signature)
    .type_(type_)
    .wallet_address(wallet_address)
    .send()
    .await;
```*/
    pub fn get_activities(&self) -> builder::GetActivities<'_> {
        builder::GetActivities::new(self)
    }
    /**CONTROLLER.TRADE.GET.TOP_TRADERS.SUMMARY

CONTROLLER.TRADE.GET.TOP_TRADERS.DESCRIPTION

Sends a `GET` request to `/v1/trade/{chain}/top-traders`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
- `cursor`: DTO.PAGE.CURSOR.DESCRIPTION
- `direction`: DTO.PAGE.DIRECTION
- `limit`: DTO.TRADE.QUERY.LIMIT
- `sort_by`: DTO.TRADE.QUERY.SORT_BY
- `sort_type`: DTO.TRADE.QUERY.SORT_TYPE
- `time_frame`: DTO.TRADE.QUERY.TIME_FRAME
- `token_address`: DTO.TRADE.QUERY.TOKEN_ADDRESS
```ignore
let response = client.get_top_traders()
    .chain(chain)
    .cursor(cursor)
    .direction(direction)
    .limit(limit)
    .sort_by(sort_by)
    .sort_type(sort_type)
    .time_frame(time_frame)
    .token_address(token_address)
    .send()
    .await;
```*/
    pub fn get_top_traders(&self) -> builder::GetTopTraders<'_> {
        builder::GetTopTraders::new(self)
    }
    /**CONTROLLER.TRADER.GET_GAINERS_LOSERS.SUMMARY

CONTROLLER.TRADER.GET_GAINERS_LOSERS.DESCRIPTION

Sends a `GET` request to `/v1/trade/{chain}/trader-gainers-losers`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
- `cursor`: DTO.PAGE.CURSOR.DESCRIPTION
- `direction`: DTO.PAGE.DIRECTION
- `limit`: DTO.PAGE.LIMIT
- `resolution`: DTO.TRADER.GAINERS_LOSERS.QUERY.RESOLUTION
- `sort_type`: DTO.TRADER.GAINERS_LOSERS.QUERY.SORT_TYPE
```ignore
let response = client.get_trader_gainers_losers()
    .chain(chain)
    .cursor(cursor)
    .direction(direction)
    .limit(limit)
    .resolution(resolution)
    .sort_type(sort_type)
    .send()
    .await;
```*/
    pub fn get_trader_gainers_losers(&self) -> builder::GetTraderGainersLosers<'_> {
        builder::GetTraderGainersLosers::new(self)
    }
    /**CONTROLLER.TRANSACTION.ESTIMATE_GAS_LIMIT.SUMMARY

CONTROLLER.TRANSACTION.ESTIMATE_GAS_LIMIT.DESCRIPTION

Sends a `POST` request to `/v1/transaction/{chain}/estimate-gas-limit`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
- `body`: CONTROLLER.TRANSACTION.ESTIMATE_GAS_LIMIT.BODY
```ignore
let response = client.get_gas_limit()
    .chain(chain)
    .body(body)
    .send()
    .await;
```*/
    pub fn get_gas_limit(&self) -> builder::GetGasLimit<'_> {
        builder::GetGasLimit::new(self)
    }
    /**CONTROLLER.TRANSACTION.GET_GAS_PRICE.SUMMARY

CONTROLLER.TRANSACTION.GET_GAS_PRICE.DESCRIPTION

Sends a `GET` request to `/v1/transaction/{chain}/gas-price`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
```ignore
let response = client.get_gas_price()
    .chain(chain)
    .send()
    .await;
```*/
    pub fn get_gas_price(&self) -> builder::GetGasPrice<'_> {
        builder::GetGasPrice::new(self)
    }
    /**CONTROLLER.TRANSACTION.SEND.SUMMARY

CONTROLLER.TRANSACTION.SEND.DESCRIPTION

Sends a `POST` request to `/v1/transaction/{chain}/send`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
- `body`: CONTROLLER.TRANSACTION.SEND.BODY
```ignore
let response = client.send()
    .chain(chain)
    .body(body)
    .send()
    .await;
```*/
    pub fn send(&self) -> builder::Send<'_> {
        builder::Send::new(self)
    }
    /**CONTROLLER.WALLET.GET_FIRST_TX.SUMMARY

CONTROLLER.WALLET.GET_FIRST_TX.DESCRIPTION

Sends a `GET` request to `/v1/wallet/{chain}/first-tx`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
- `wallet_addresses`: GLOBAL.WALLETADDRESSES.DESCRIPTION
```ignore
let response = client.get_wallet_first_tx()
    .chain(chain)
    .wallet_addresses(wallet_addresses)
    .send()
    .await;
```*/
    pub fn get_wallet_first_tx(&self) -> builder::GetWalletFirstTx<'_> {
        builder::GetWalletFirstTx::new(self)
    }
    /**CONTROLLER.WALLET.GET_NET_WORTH_SUMMARY.SUMMARY

CONTROLLER.WALLET.GET_NET_WORTH_SUMMARY.DESCRIPTION

Sends a `GET` request to `/v1/wallet/{chain}/net-worth-summary`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
- `wallet_addresses`: GLOBAL.WALLETADDRESSES.DESCRIPTION
```ignore
let response = client.get_net_worth_summary()
    .chain(chain)
    .wallet_addresses(wallet_addresses)
    .send()
    .await;
```*/
    pub fn get_net_worth_summary(&self) -> builder::GetNetWorthSummary<'_> {
        builder::GetNetWorthSummary::new(self)
    }
    /**CONTROLLER.WALLET.GET_PNL_BY_WALLET.SUMMARY

CONTROLLER.WALLET.GET_PNL_BY_WALLET.DESCRIPTION

Sends a `GET` request to `/v1/wallet/{chain}/pnl-by-wallet`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
- `cursor`: DTO.PAGE.CURSOR.DESCRIPTION
- `direction`: DTO.PAGE.DIRECTION
- `limit`: DTO.PAGE.LIMIT
- `token_address`: GLOBAL.TOKENADDRESS.DESCRIPTION
- `wallet_addresses`: GLOBAL.WALLETADDRESSES.DESCRIPTION
```ignore
let response = client.get_pnl_by_wallet()
    .chain(chain)
    .cursor(cursor)
    .direction(direction)
    .limit(limit)
    .token_address(token_address)
    .wallet_addresses(wallet_addresses)
    .send()
    .await;
```*/
    pub fn get_pnl_by_wallet(&self) -> builder::GetPnlByWallet<'_> {
        builder::GetPnlByWallet::new(self)
    }
    /**CONTROLLER.WALLET.GET_BALANCE_UPDATES.SUMMARY

CONTROLLER.WALLET.GET_BALANCE_UPDATES.DESCRIPTION

Sends a `GET` request to `/v1/wallet/{chain}/{walletAddress}/balance-updates`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
- `wallet_address`: GLOBAL.WALLETADDRESS.DESCRIPTION
- `change_type`: DTO.WALLET.BALANCE_UPDATE.QUERY.CHANGE_TYPE
- `cursor`: DTO.PAGE.CURSOR.DESCRIPTION
- `direction`: DTO.PAGE.DIRECTION
- `limit`: DTO.PAGE.LIMIT
- `time_from`: DTO.WALLET.BALANCE_UPDATE.QUERY.TIME_FROM
- `time_to`: DTO.WALLET.BALANCE_UPDATE.QUERY.TIME_TO
- `token_address`: DTO.WALLET.BALANCE_UPDATE.QUERY.TOKEN_ADDRESS
- `type_`: DTO.WALLET.BALANCE_UPDATE.QUERY.TYPE
```ignore
let response = client.get_balance_updates()
    .chain(chain)
    .wallet_address(wallet_address)
    .change_type(change_type)
    .cursor(cursor)
    .direction(direction)
    .limit(limit)
    .time_from(time_from)
    .time_to(time_to)
    .token_address(token_address)
    .type_(type_)
    .send()
    .await;
```*/
    pub fn get_balance_updates(&self) -> builder::GetBalanceUpdates<'_> {
        builder::GetBalanceUpdates::new(self)
    }
    /**CONTROLLER.WALLET.CALCULATE_PNL.SUMMARY

CONTROLLER.WALLET.CALCULATE_PNL.DESCRIPTION

Sends a `POST` request to `/v1/wallet/{chain}/{walletAddress}/calculate-pnl`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
- `wallet_address`: GLOBAL.WALLETADDRESS.DESCRIPTION
- `body`
```ignore
let response = client.calculate_pnl()
    .chain(chain)
    .wallet_address(wallet_address)
    .body(body)
    .send()
    .await;
```*/
    pub fn calculate_pnl(&self) -> builder::CalculatePnl<'_> {
        builder::CalculatePnl::new(self)
    }
    /**CONTROLLER.WALLET.GET_NET_WORTH.SUMMARY

CONTROLLER.WALLET.GET_NET_WORTH.DESCRIPTION

Sends a `GET` request to `/v1/wallet/{chain}/{walletAddress}/net-worth`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
- `wallet_address`: GLOBAL.WALLETADDRESS.DESCRIPTION
- `cursor`: DTO.PAGE.CURSOR.DESCRIPTION
- `direction`: DTO.PAGE.DIRECTION
- `limit`: DTO.PAGE.LIMIT
```ignore
let response = client.get_net_worth()
    .chain(chain)
    .wallet_address(wallet_address)
    .cursor(cursor)
    .direction(direction)
    .limit(limit)
    .send()
    .await;
```*/
    pub fn get_net_worth(&self) -> builder::GetNetWorth<'_> {
        builder::GetNetWorth::new(self)
    }
    /**CONTROLLER.WALLET.GET_NET_WORTH_CHART.SUMMARY

CONTROLLER.WALLET.GET_NET_WORTH_CHART.DESCRIPTION

Sends a `GET` request to `/v1/wallet/{chain}/{walletAddress}/net-worth-chart`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
- `wallet_address`: GLOBAL.WALLETADDRESS.DESCRIPTION
- `hours`: DTO.WALLET.NET_WORTH_CHART.QUERY.HOURS
```ignore
let response = client.get_net_worth_chart()
    .chain(chain)
    .wallet_address(wallet_address)
    .hours(hours)
    .send()
    .await;
```*/
    pub fn get_net_worth_chart(&self) -> builder::GetNetWorthChart<'_> {
        builder::GetNetWorthChart::new(self)
    }
    /**CONTROLLER.WALLET.GET_NET_WORTH_DETAILS.SUMMARY

CONTROLLER.WALLET.GET_NET_WORTH_DETAILS.DESCRIPTION

Sends a `GET` request to `/v1/wallet/{chain}/{walletAddress}/net-worth-details`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
- `wallet_address`: GLOBAL.WALLETADDRESS.DESCRIPTION
- `cursor`: DTO.PAGE.CURSOR.DESCRIPTION
- `direction`: DTO.PAGE.DIRECTION
- `hours`: DTO.WALLET.NET_WORTH_DETAILS.QUERY.HOURS
- `limit`: DTO.PAGE.LIMIT
```ignore
let response = client.get_net_worth_details()
    .chain(chain)
    .wallet_address(wallet_address)
    .cursor(cursor)
    .direction(direction)
    .hours(hours)
    .limit(limit)
    .send()
    .await;
```*/
    pub fn get_net_worth_details(&self) -> builder::GetNetWorthDetails<'_> {
        builder::GetNetWorthDetails::new(self)
    }
    /**CONTROLLER.WALLET.GET_PNL_SUMMARY.SUMMARY

CONTROLLER.WALLET.GET_PNL_SUMMARY.DESCRIPTION

Sends a `GET` request to `/v1/wallet/{chain}/{walletAddress}/pnl`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
- `wallet_address`: GLOBAL.WALLETADDRESS.DESCRIPTION
- `resolution`: DTO.WALLET.PNL_SUMMARY.QUERY.RESOLUTION
```ignore
let response = client.get_pnl()
    .chain(chain)
    .wallet_address(wallet_address)
    .resolution(resolution)
    .send()
    .await;
```*/
    pub fn get_pnl(&self) -> builder::GetPnl<'_> {
        builder::GetPnl::new(self)
    }
    /**CONTROLLER.WALLET.GET_PNL_BY_TOKEN.SUMMARY

CONTROLLER.WALLET.GET_PNL_BY_TOKEN.DESCRIPTION

Sends a `GET` request to `/v1/wallet/{chain}/{walletAddress}/pnl-by-token`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
- `wallet_address`: GLOBAL.WALLETADDRESS.DESCRIPTION
- `cursor`: DTO.PAGE.CURSOR.DESCRIPTION
- `direction`: DTO.PAGE.DIRECTION
- `limit`: DTO.PAGE.LIMIT
- `token_addresses`: GLOBAL.TOKENADDRESSES.DESCRIPTION
```ignore
let response = client.get_pnl_by_token()
    .chain(chain)
    .wallet_address(wallet_address)
    .cursor(cursor)
    .direction(direction)
    .limit(limit)
    .token_addresses(token_addresses)
    .send()
    .await;
```*/
    pub fn get_pnl_by_token(&self) -> builder::GetPnlByToken<'_> {
        builder::GetPnlByToken::new(self)
    }
    /**CONTROLLER.WALLET.GET_PNL_DETAILS.SUMMARY

CONTROLLER.WALLET.GET_PNL_DETAILS.DESCRIPTION

Sends a `GET` request to `/v1/wallet/{chain}/{walletAddress}/pnl-details`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
- `wallet_address`: GLOBAL.WALLETADDRESS.DESCRIPTION
- `cursor`: DTO.PAGE.CURSOR.DESCRIPTION
- `direction`: DTO.PAGE.DIRECTION
- `limit`: DTO.PAGE.LIMIT
```ignore
let response = client.get_pnl_details()
    .chain(chain)
    .wallet_address(wallet_address)
    .cursor(cursor)
    .direction(direction)
    .limit(limit)
    .send()
    .await;
```*/
    pub fn get_pnl_details(&self) -> builder::GetPnlDetails<'_> {
        builder::GetPnlDetails::new(self)
    }
    /**CONTROLLER.WALLET.GET_TOKENS_BALANCE.SUMMARY

CONTROLLER.WALLET.GET_TOKENS_BALANCE.DESCRIPTION

Sends a `GET` request to `/v1/wallet/{chain}/{walletAddress}/tokens-balance`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
- `wallet_address`: GLOBAL.WALLETADDRESS.DESCRIPTION
- `cursor`: DTO.PAGE.CURSOR.DESCRIPTION
- `direction`: DTO.PAGE.DIRECTION
- `limit`: DTO.PAGE.LIMIT
```ignore
let response = client.get_tokens_balance()
    .chain(chain)
    .wallet_address(wallet_address)
    .cursor(cursor)
    .direction(direction)
    .limit(limit)
    .send()
    .await;
```*/
    pub fn get_tokens_balance(&self) -> builder::GetTokensBalance<'_> {
        builder::GetTokensBalance::new(self)
    }
    /**CONTROLLER.WALLET.GET_TRANSFER_TOTAL.SUMMARY

CONTROLLER.WALLET.GET_TRANSFER_TOTAL.DESCRIPTION

Sends a `GET` request to `/v1/wallet/{chain}/{walletAddress}/transfer-total`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
- `wallet_address`: GLOBAL.WALLETADDRESS.DESCRIPTION
- `after_timestamp`: DTO.TOKEN.TRANSFER.QUERY.AFTER_TIMESTAMP
- `before_timestamp`: DTO.TOKEN.TRANSFER.QUERY.BEFORE_TIMESTAMP
- `cursor`: DTO.PAGE.CURSOR.DESCRIPTION
- `direction`: DTO.PAGE.DIRECTION
- `limit`: DTO.PAGE.LIMIT
- `max_token_amount`: DTO.WALLET.TRANSFER.QUERY.MAX_TOKEN_AMOUNT
- `max_token_amount_in_usd`: DTO.WALLET.TRANSFER.QUERY.MAX_TOKEN_AMOUNT_IN_USD
- `min_token_amount`: DTO.WALLET.TRANSFER.QUERY.MIN_TOKEN_AMOUNT
- `min_token_amount_in_usd`: DTO.WALLET.TRANSFER.QUERY.MIN_TOKEN_AMOUNT_IN_USD
- `token_address`: GLOBAL.TOKENADDRESS.DESCRIPTION
```ignore
let response = client.get_wallet_transfer_total()
    .chain(chain)
    .wallet_address(wallet_address)
    .after_timestamp(after_timestamp)
    .before_timestamp(before_timestamp)
    .cursor(cursor)
    .direction(direction)
    .limit(limit)
    .max_token_amount(max_token_amount)
    .max_token_amount_in_usd(max_token_amount_in_usd)
    .min_token_amount(min_token_amount)
    .min_token_amount_in_usd(min_token_amount_in_usd)
    .token_address(token_address)
    .send()
    .await;
```*/
    pub fn get_wallet_transfer_total(&self) -> builder::GetWalletTransferTotal<'_> {
        builder::GetWalletTransferTotal::new(self)
    }
    /**CONTROLLER.WALLET.GET_TRANSFERS.SUMMARY

CONTROLLER.WALLET.GET_TRANSFERS.DESCRIPTION

Sends a `GET` request to `/v1/wallet/{chain}/{walletAddress}/transfers`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
- `wallet_address`: GLOBAL.WALLETADDRESS.DESCRIPTION
- `after_timestamp`: DTO.TOKEN.TRANSFER.QUERY.AFTER_TIMESTAMP
- `before_timestamp`: DTO.TOKEN.TRANSFER.QUERY.BEFORE_TIMESTAMP
- `cursor`: DTO.PAGE.CURSOR.DESCRIPTION
- `direction`: DTO.PAGE.DIRECTION
- `limit`: DTO.PAGE.LIMIT
- `max_token_amount`: DTO.WALLET.TRANSFER.QUERY.MAX_TOKEN_AMOUNT
- `max_token_amount_in_usd`: DTO.WALLET.TRANSFER.QUERY.MAX_TOKEN_AMOUNT_IN_USD
- `min_token_amount`: DTO.WALLET.TRANSFER.QUERY.MIN_TOKEN_AMOUNT
- `min_token_amount_in_usd`: DTO.WALLET.TRANSFER.QUERY.MIN_TOKEN_AMOUNT_IN_USD
- `token_address`: GLOBAL.TOKENADDRESS.DESCRIPTION
```ignore
let response = client.get_wallet_transfers()
    .chain(chain)
    .wallet_address(wallet_address)
    .after_timestamp(after_timestamp)
    .before_timestamp(before_timestamp)
    .cursor(cursor)
    .direction(direction)
    .limit(limit)
    .max_token_amount(max_token_amount)
    .max_token_amount_in_usd(max_token_amount_in_usd)
    .min_token_amount(min_token_amount)
    .min_token_amount_in_usd(min_token_amount_in_usd)
    .token_address(token_address)
    .send()
    .await;
```*/
    pub fn get_wallet_transfers(&self) -> builder::GetWalletTransfers<'_> {
        builder::GetWalletTransfers::new(self)
    }
    /**CONTROLLER.WATCHLIST.ADD.SUMMARY

CONTROLLER.WATCHLIST.ADD.DESCRIPTION

Sends a `POST` request to `/v1/watchlist/{chain}/{walletAddress}`

Arguments:
- `chain`: GLOBAL.CHAIN.DESCRIPTION
- `wallet_address`: GLOBAL.WALLETADDRESS.DESCRIPTION
```ignore
let response = client.watchlist_add()
    .chain(chain)
    .wallet_address(wallet_address)
    .send()
    .await;
```*/
    pub fn watchlist_add(&self) -> builder::WatchlistAdd<'_> {
        builder::WatchlistAdd::new(self)
    }
    /**CONTROLLER.ENDPOINT.LIST.SUMMARY

CONTROLLER.ENDPOINT.LIST.DESCRIPTION

Sends a `GET` request to `/v1/webhook/endpoint`

Arguments:
- `iterator`: DTO.ENDPOINT.ITERATOR
- `limit`: DTO.ENDPOINT.LIMIT
- `order`: DTO.ENDPOINT.ORDER
```ignore
let response = client.list_endpoints()
    .iterator(iterator)
    .limit(limit)
    .order(order)
    .send()
    .await;
```*/
    pub fn list_endpoints(&self) -> builder::ListEndpoints<'_> {
        builder::ListEndpoints::new(self)
    }
    /**CONTROLLER.ENDPOINT.CREATE.SUMMARY

CONTROLLER.ENDPOINT.CREATE.DESCRIPTION

Sends a `POST` request to `/v1/webhook/endpoint`

```ignore
let response = client.create_endpoint()
    .body(body)
    .send()
    .await;
```*/
    pub fn create_endpoint(&self) -> builder::CreateEndpoint<'_> {
        builder::CreateEndpoint::new(self)
    }
    /**CONTROLLER.ENDPOINT.UPDATE.SUMMARY

CONTROLLER.ENDPOINT.UPDATE.DESCRIPTION

Sends a `PATCH` request to `/v1/webhook/endpoint`

```ignore
let response = client.update_endpoint()
    .body(body)
    .send()
    .await;
```*/
    pub fn update_endpoint(&self) -> builder::UpdateEndpoint<'_> {
        builder::UpdateEndpoint::new(self)
    }
    /**CONTROLLER.ENDPOINT.GET.SUMMARY

CONTROLLER.ENDPOINT.GET.DESCRIPTION

Sends a `GET` request to `/v1/webhook/endpoint/{id}`

```ignore
let response = client.get_endpoint()
    .id(id)
    .send()
    .await;
```*/
    pub fn get_endpoint(&self) -> builder::GetEndpoint<'_> {
        builder::GetEndpoint::new(self)
    }
    /**CONTROLLER.ENDPOINT.DELETE.SUMMARY

CONTROLLER.ENDPOINT.DELETE.DESCRIPTION

Sends a `DELETE` request to `/v1/webhook/endpoint/{id}`

```ignore
let response = client.delete_endpoint()
    .id(id)
    .send()
    .await;
```*/
    pub fn delete_endpoint(&self) -> builder::DeleteEndpoint<'_> {
        builder::DeleteEndpoint::new(self)
    }
    /**CONTROLLER.ENDPOINT.GET.SECRET.SUMMARY

CONTROLLER.ENDPOINT.GET.SECRET.DESCRIPTION

Sends a `GET` request to `/v1/webhook/endpoint/{id}/secret`

```ignore
let response = client.get_endpoint_secret()
    .id(id)
    .send()
    .await;
```*/
    pub fn get_endpoint_secret(&self) -> builder::GetEndpointSecret<'_> {
        builder::GetEndpointSecret::new(self)
    }
    /**CONTROLLER.ENDPOINT.ROTATE.SUMMARY

CONTROLLER.ENDPOINT.ROTATE.DESCRIPTION

Sends a `POST` request to `/v1/webhook/endpoint/{id}/secret/rotate`

```ignore
let response = client.rotate_endpoint_secret()
    .id(id)
    .send()
    .await;
```*/
    pub fn rotate_endpoint_secret(&self) -> builder::RotateEndpointSecret<'_> {
        builder::RotateEndpointSecret::new(self)
    }
}
/// Types for composing operation parameters.
#[allow(clippy::all)]
pub mod builder {
    use super::types;
    #[allow(unused_imports)]
    use super::{
        encode_path, ByteStream, ClientInfo, ClientHooks, Error, OperationInfo,
        RequestBuilderExt, ResponseValue,
    };
    /**Builder for [`Client::get_supported_blockchains`]

[`Client::get_supported_blockchains`]: super::Client::get_supported_blockchains*/
    #[derive(Debug, Clone)]
    pub struct GetSupportedBlockchains<'a> {
        client: &'a super::Client,
    }
    impl<'a> GetSupportedBlockchains<'a> {
        pub fn new(client: &'a super::Client) -> Self {
            Self { client: client }
        }
        ///Sends a `GET` request to `/v1/blockchain`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<::std::vec::Vec<types::BlockchainDto>>, Error<()>> {
            let Self { client } = self;
            let url = format!("{}/v1/blockchain", client.baseurl,);
            let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
            header_map
                .append(
                    ::reqwest::header::HeaderName::from_static("api-version"),
                    ::reqwest::header::HeaderValue::from_static(
                        super::Client::api_version(),
                    ),
                );
            #[allow(unused_mut)]
            let mut request = client
                .client
                .get(url)
                .header(
                    ::reqwest::header::ACCEPT,
                    ::reqwest::header::HeaderValue::from_static("application/json"),
                )
                .headers(header_map)
                .build()?;
            let info = OperationInfo {
                operation_id: "get_supported_blockchains",
            };
            client.pre(&mut request, &info).await?;
            let result = client.exec(request, &info).await;
            client.post(&result, &info).await?;
            let response = result?;
            match response.status().as_u16() {
                200u16 => ResponseValue::from_response::<()>(response).await,
                _ => Err(Error::UnexpectedResponse(response)),
            }
        }
    }
    /**Builder for [`Client::get_latest_block`]

[`Client::get_latest_block`]: super::Client::get_latest_block*/
    #[derive(Debug, Clone)]
    pub struct GetLatestBlock<'a> {
        client: &'a super::Client,
        chain: Result<types::ChainSymbol, String>,
    }
    impl<'a> GetLatestBlock<'a> {
        pub fn new(client: &'a super::Client) -> Self {
            Self {
                client: client,
                chain: Err("chain was not initialized".to_string()),
            }
        }
        pub fn chain<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::ChainSymbol>,
        {
            self.chain = value
                .try_into()
                .map_err(|_| "conversion to `ChainSymbol` for chain failed".to_string());
            self
        }
        ///Sends a `GET` request to `/v1/blockchain/{chain}/latest_block`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::BlockchainLatestBlockDto>, Error<()>> {
            let Self { client, chain } = self;
            let chain = chain.map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v1/blockchain/{}/latest_block", client.baseurl, encode_path(& chain
                .to_string()),
            );
            let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
            header_map
                .append(
                    ::reqwest::header::HeaderName::from_static("api-version"),
                    ::reqwest::header::HeaderValue::from_static(
                        super::Client::api_version(),
                    ),
                );
            #[allow(unused_mut)]
            let mut request = client
                .client
                .get(url)
                .header(
                    ::reqwest::header::ACCEPT,
                    ::reqwest::header::HeaderValue::from_static("application/json"),
                )
                .headers(header_map)
                .build()?;
            let info = OperationInfo {
                operation_id: "get_latest_block",
            };
            client.pre(&mut request, &info).await?;
            let result = client.exec(request, &info).await;
            client.post(&result, &info).await?;
            let response = result?;
            match response.status().as_u16() {
                200u16 => ResponseValue::from_response::<()>(response).await,
                _ => Err(Error::UnexpectedResponse(response)),
            }
        }
    }
    /**Builder for [`Client::list_dex`]

[`Client::list_dex`]: super::Client::list_dex*/
    #[derive(Debug, Clone)]
    pub struct ListDex<'a> {
        client: &'a super::Client,
        chains: Result<Option<::std::vec::Vec<::std::string::String>>, String>,
        dex_program: Result<Option<::std::string::String>, String>,
        limit: Result<Option<::std::num::NonZeroU64>, String>,
    }
    impl<'a> ListDex<'a> {
        pub fn new(client: &'a super::Client) -> Self {
            Self {
                client: client,
                chains: Ok(None),
                dex_program: Ok(None),
                limit: Ok(None),
            }
        }
        pub fn chains<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::vec::Vec<::std::string::String>>,
        {
            self.chains = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: vec :: Vec < :: std :: string :: String >` for chains failed"
                        .to_string()
                });
            self
        }
        pub fn dex_program<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.dex_program = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for dex_program failed"
                        .to_string()
                });
            self
        }
        pub fn limit<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::num::NonZeroU64>,
        {
            self.limit = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: num :: NonZeroU64` for limit failed"
                        .to_string()
                });
            self
        }
        ///Sends a `GET` request to `/v1/dex`
        pub async fn send(self) -> Result<ResponseValue<types::DexPage>, Error<()>> {
            let Self { client, chains, dex_program, limit } = self;
            let chains = chains.map_err(Error::InvalidRequest)?;
            let dex_program = dex_program.map_err(Error::InvalidRequest)?;
            let limit = limit.map_err(Error::InvalidRequest)?;
            let url = format!("{}/v1/dex", client.baseurl,);
            let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
            header_map
                .append(
                    ::reqwest::header::HeaderName::from_static("api-version"),
                    ::reqwest::header::HeaderValue::from_static(
                        super::Client::api_version(),
                    ),
                );
            #[allow(unused_mut)]
            let mut request = client
                .client
                .get(url)
                .header(
                    ::reqwest::header::ACCEPT,
                    ::reqwest::header::HeaderValue::from_static("application/json"),
                )
                .query(&progenitor_middleware_client::QueryParam::new("chains", &chains))
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "dexProgram",
                        &dex_program,
                    ),
                )
                .query(&progenitor_middleware_client::QueryParam::new("limit", &limit))
                .headers(header_map)
                .build()?;
            let info = OperationInfo {
                operation_id: "list_dex",
            };
            client.pre(&mut request, &info).await?;
            let result = client.exec(request, &info).await;
            client.post(&result, &info).await?;
            let response = result?;
            match response.status().as_u16() {
                200u16 => ResponseValue::from_response::<()>(response).await,
                _ => Err(Error::UnexpectedResponse(response)),
            }
        }
    }
    /**Builder for [`Client::create_token`]

[`Client::create_token`]: super::Client::create_token*/
    #[derive(Debug, Clone)]
    pub struct CreateToken<'a> {
        client: &'a super::Client,
        chain: Result<types::ChainSymbol, String>,
        body: Result<types::builder::CreateTokenInput, String>,
    }
    impl<'a> CreateToken<'a> {
        pub fn new(client: &'a super::Client) -> Self {
            Self {
                client: client,
                chain: Err("chain was not initialized".to_string()),
                body: Ok(::std::default::Default::default()),
            }
        }
        pub fn chain<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::ChainSymbol>,
        {
            self.chain = value
                .try_into()
                .map_err(|_| "conversion to `ChainSymbol` for chain failed".to_string());
            self
        }
        pub fn body<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::CreateTokenInput>,
            <V as std::convert::TryInto<
                types::CreateTokenInput,
            >>::Error: std::fmt::Display,
        {
            self.body = value
                .try_into()
                .map(From::from)
                .map_err(|s| {
                    format!("conversion to `CreateTokenInput` for body failed: {}", s)
                });
            self
        }
        pub fn body_map<F>(mut self, f: F) -> Self
        where
            F: std::ops::FnOnce(
                types::builder::CreateTokenInput,
            ) -> types::builder::CreateTokenInput,
        {
            self.body = self.body.map(f);
            self
        }
        ///Sends a `POST` request to `/v1/dex/{chain}/create`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::CreateTokenReply>, Error<()>> {
            let Self { client, chain, body } = self;
            let chain = chain.map_err(Error::InvalidRequest)?;
            let body = body
                .and_then(|v| {
                    types::CreateTokenInput::try_from(v).map_err(|e| e.to_string())
                })
                .map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v1/dex/{}/create", client.baseurl, encode_path(& chain.to_string()),
            );
            let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
            header_map
                .append(
                    ::reqwest::header::HeaderName::from_static("api-version"),
                    ::reqwest::header::HeaderValue::from_static(
                        super::Client::api_version(),
                    ),
                );
            #[allow(unused_mut)]
            let mut request = client
                .client
                .post(url)
                .header(
                    ::reqwest::header::ACCEPT,
                    ::reqwest::header::HeaderValue::from_static("application/json"),
                )
                .json(&body)
                .headers(header_map)
                .build()?;
            let info = OperationInfo {
                operation_id: "create_token",
            };
            client.pre(&mut request, &info).await?;
            let result = client.exec(request, &info).await;
            client.post(&result, &info).await?;
            let response = result?;
            match response.status().as_u16() {
                200u16 => ResponseValue::from_response::<()>(response).await,
                _ => Err(Error::UnexpectedResponse(response)),
            }
        }
    }
    /**Builder for [`Client::quote`]

[`Client::quote`]: super::Client::quote*/
    #[derive(Debug, Clone)]
    pub struct Quote<'a> {
        client: &'a super::Client,
        chain: Result<types::ChainSymbol, String>,
        amount: Result<::std::string::String, String>,
        dex: Result<types::QuoteDex, String>,
        exact_in: Result<bool, String>,
        input_mint: Result<::std::string::String, String>,
        output_mint: Result<::std::string::String, String>,
        slippage: Result<i64, String>,
    }
    impl<'a> Quote<'a> {
        pub fn new(client: &'a super::Client) -> Self {
            Self {
                client: client,
                chain: Err("chain was not initialized".to_string()),
                amount: Err("amount was not initialized".to_string()),
                dex: Err("dex was not initialized".to_string()),
                exact_in: Err("exact_in was not initialized".to_string()),
                input_mint: Err("input_mint was not initialized".to_string()),
                output_mint: Err("output_mint was not initialized".to_string()),
                slippage: Err("slippage was not initialized".to_string()),
            }
        }
        pub fn chain<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::ChainSymbol>,
        {
            self.chain = value
                .try_into()
                .map_err(|_| "conversion to `ChainSymbol` for chain failed".to_string());
            self
        }
        pub fn amount<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.amount = value
                .try_into()
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for amount failed"
                        .to_string()
                });
            self
        }
        pub fn dex<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::QuoteDex>,
        {
            self.dex = value
                .try_into()
                .map_err(|_| "conversion to `QuoteDex` for dex failed".to_string());
            self
        }
        pub fn exact_in<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<bool>,
        {
            self.exact_in = value
                .try_into()
                .map_err(|_| "conversion to `bool` for exact_in failed".to_string());
            self
        }
        pub fn input_mint<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.input_mint = value
                .try_into()
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for input_mint failed"
                        .to_string()
                });
            self
        }
        pub fn output_mint<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.output_mint = value
                .try_into()
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for output_mint failed"
                        .to_string()
                });
            self
        }
        pub fn slippage<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<i64>,
        {
            self.slippage = value
                .try_into()
                .map_err(|_| "conversion to `i64` for slippage failed".to_string());
            self
        }
        ///Sends a `GET` request to `/v1/dex/{chain}/quote`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::DexQuoteResponse>, Error<()>> {
            let Self {
                client,
                chain,
                amount,
                dex,
                exact_in,
                input_mint,
                output_mint,
                slippage,
            } = self;
            let chain = chain.map_err(Error::InvalidRequest)?;
            let amount = amount.map_err(Error::InvalidRequest)?;
            let dex = dex.map_err(Error::InvalidRequest)?;
            let exact_in = exact_in.map_err(Error::InvalidRequest)?;
            let input_mint = input_mint.map_err(Error::InvalidRequest)?;
            let output_mint = output_mint.map_err(Error::InvalidRequest)?;
            let slippage = slippage.map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v1/dex/{}/quote", client.baseurl, encode_path(& chain.to_string()),
            );
            let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
            header_map
                .append(
                    ::reqwest::header::HeaderName::from_static("api-version"),
                    ::reqwest::header::HeaderValue::from_static(
                        super::Client::api_version(),
                    ),
                );
            #[allow(unused_mut)]
            let mut request = client
                .client
                .get(url)
                .header(
                    ::reqwest::header::ACCEPT,
                    ::reqwest::header::HeaderValue::from_static("application/json"),
                )
                .query(&progenitor_middleware_client::QueryParam::new("amount", &amount))
                .query(&progenitor_middleware_client::QueryParam::new("dex", &dex))
                .query(
                    &progenitor_middleware_client::QueryParam::new("exactIn", &exact_in),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "inputMint",
                        &input_mint,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "outputMint",
                        &output_mint,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new("slippage", &slippage),
                )
                .headers(header_map)
                .build()?;
            let info = OperationInfo {
                operation_id: "quote",
            };
            client.pre(&mut request, &info).await?;
            let result = client.exec(request, &info).await;
            client.post(&result, &info).await?;
            let response = result?;
            match response.status().as_u16() {
                200u16 => ResponseValue::from_response::<()>(response).await,
                _ => Err(Error::UnexpectedResponse(response)),
            }
        }
    }
    /**Builder for [`Client::route`]

[`Client::route`]: super::Client::route*/
    #[derive(Debug, Clone)]
    pub struct Route<'a> {
        client: &'a super::Client,
        chain: Result<types::ChainSymbol, String>,
        body: Result<types::builder::SwapRouteInput, String>,
    }
    impl<'a> Route<'a> {
        pub fn new(client: &'a super::Client) -> Self {
            Self {
                client: client,
                chain: Err("chain was not initialized".to_string()),
                body: Ok(::std::default::Default::default()),
            }
        }
        pub fn chain<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::ChainSymbol>,
        {
            self.chain = value
                .try_into()
                .map_err(|_| "conversion to `ChainSymbol` for chain failed".to_string());
            self
        }
        pub fn body<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::SwapRouteInput>,
            <V as std::convert::TryInto<
                types::SwapRouteInput,
            >>::Error: std::fmt::Display,
        {
            self.body = value
                .try_into()
                .map(From::from)
                .map_err(|s| {
                    format!("conversion to `SwapRouteInput` for body failed: {}", s)
                });
            self
        }
        pub fn body_map<F>(mut self, f: F) -> Self
        where
            F: std::ops::FnOnce(
                types::builder::SwapRouteInput,
            ) -> types::builder::SwapRouteInput,
        {
            self.body = self.body.map(f);
            self
        }
        ///Sends a `POST` request to `/v1/dex/{chain}/route`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::SwapRouteResponse>, Error<()>> {
            let Self { client, chain, body } = self;
            let chain = chain.map_err(Error::InvalidRequest)?;
            let body = body
                .and_then(|v| {
                    types::SwapRouteInput::try_from(v).map_err(|e| e.to_string())
                })
                .map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v1/dex/{}/route", client.baseurl, encode_path(& chain.to_string()),
            );
            let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
            header_map
                .append(
                    ::reqwest::header::HeaderName::from_static("api-version"),
                    ::reqwest::header::HeaderValue::from_static(
                        super::Client::api_version(),
                    ),
                );
            #[allow(unused_mut)]
            let mut request = client
                .client
                .post(url)
                .header(
                    ::reqwest::header::ACCEPT,
                    ::reqwest::header::HeaderValue::from_static("application/json"),
                )
                .json(&body)
                .headers(header_map)
                .build()?;
            let info = OperationInfo {
                operation_id: "route",
            };
            client.pre(&mut request, &info).await?;
            let result = client.exec(request, &info).await;
            client.post(&result, &info).await?;
            let response = result?;
            match response.status().as_u16() {
                200u16 => ResponseValue::from_response::<()>(response).await,
                _ => Err(Error::UnexpectedResponse(response)),
            }
        }
    }
    /**Builder for [`Client::swap`]

[`Client::swap`]: super::Client::swap*/
    #[derive(Debug, Clone)]
    pub struct Swap<'a> {
        client: &'a super::Client,
        chain: Result<types::ChainSymbol, String>,
        body: Result<types::builder::SwapInput, String>,
    }
    impl<'a> Swap<'a> {
        pub fn new(client: &'a super::Client) -> Self {
            Self {
                client: client,
                chain: Err("chain was not initialized".to_string()),
                body: Ok(::std::default::Default::default()),
            }
        }
        pub fn chain<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::ChainSymbol>,
        {
            self.chain = value
                .try_into()
                .map_err(|_| "conversion to `ChainSymbol` for chain failed".to_string());
            self
        }
        pub fn body<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::SwapInput>,
            <V as std::convert::TryInto<types::SwapInput>>::Error: std::fmt::Display,
        {
            self.body = value
                .try_into()
                .map(From::from)
                .map_err(|s| {
                    format!("conversion to `SwapInput` for body failed: {}", s)
                });
            self
        }
        pub fn body_map<F>(mut self, f: F) -> Self
        where
            F: std::ops::FnOnce(types::builder::SwapInput) -> types::builder::SwapInput,
        {
            self.body = self.body.map(f);
            self
        }
        ///Sends a `POST` request to `/v1/dex/{chain}/swap`
        pub async fn send(self) -> Result<ResponseValue<types::SwapReply>, Error<()>> {
            let Self { client, chain, body } = self;
            let chain = chain.map_err(Error::InvalidRequest)?;
            let body = body
                .and_then(|v| types::SwapInput::try_from(v).map_err(|e| e.to_string()))
                .map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v1/dex/{}/swap", client.baseurl, encode_path(& chain.to_string()),
            );
            let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
            header_map
                .append(
                    ::reqwest::header::HeaderName::from_static("api-version"),
                    ::reqwest::header::HeaderValue::from_static(
                        super::Client::api_version(),
                    ),
                );
            #[allow(unused_mut)]
            let mut request = client
                .client
                .post(url)
                .header(
                    ::reqwest::header::ACCEPT,
                    ::reqwest::header::HeaderValue::from_static("application/json"),
                )
                .json(&body)
                .headers(header_map)
                .build()?;
            let info = OperationInfo {
                operation_id: "swap",
            };
            client.pre(&mut request, &info).await?;
            let result = client.exec(request, &info).await;
            client.post(&result, &info).await?;
            let response = result?;
            match response.status().as_u16() {
                200u16 => ResponseValue::from_response::<()>(response).await,
                _ => Err(Error::UnexpectedResponse(response)),
            }
        }
    }
    /**Builder for [`Client::get_dexpool`]

[`Client::get_dexpool`]: super::Client::get_dexpool*/
    #[derive(Debug, Clone)]
    pub struct GetDexpool<'a> {
        client: &'a super::Client,
        chain: Result<types::ChainSymbol, String>,
        pool_address: Result<::std::string::String, String>,
    }
    impl<'a> GetDexpool<'a> {
        pub fn new(client: &'a super::Client) -> Self {
            Self {
                client: client,
                chain: Err("chain was not initialized".to_string()),
                pool_address: Err("pool_address was not initialized".to_string()),
            }
        }
        pub fn chain<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::ChainSymbol>,
        {
            self.chain = value
                .try_into()
                .map_err(|_| "conversion to `ChainSymbol` for chain failed".to_string());
            self
        }
        pub fn pool_address<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.pool_address = value
                .try_into()
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for pool_address failed"
                        .to_string()
                });
            self
        }
        ///Sends a `GET` request to `/v1/dexpools/{chain}/{poolAddress}`
        pub async fn send(self) -> Result<ResponseValue<types::DexPoolDto>, Error<()>> {
            let Self { client, chain, pool_address } = self;
            let chain = chain.map_err(Error::InvalidRequest)?;
            let pool_address = pool_address.map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v1/dexpools/{}/{}", client.baseurl, encode_path(& chain.to_string()),
                encode_path(& pool_address.to_string()),
            );
            let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
            header_map
                .append(
                    ::reqwest::header::HeaderName::from_static("api-version"),
                    ::reqwest::header::HeaderValue::from_static(
                        super::Client::api_version(),
                    ),
                );
            #[allow(unused_mut)]
            let mut request = client
                .client
                .get(url)
                .header(
                    ::reqwest::header::ACCEPT,
                    ::reqwest::header::HeaderValue::from_static("application/json"),
                )
                .headers(header_map)
                .build()?;
            let info = OperationInfo {
                operation_id: "get_dexpool",
            };
            client.pre(&mut request, &info).await?;
            let result = client.exec(request, &info).await;
            client.post(&result, &info).await?;
            let response = result?;
            match response.status().as_u16() {
                200u16 => ResponseValue::from_response::<()>(response).await,
                _ => Err(Error::UnexpectedResponse(response)),
            }
        }
    }
    /**Builder for [`Client::get_dexpool_snapshots`]

[`Client::get_dexpool_snapshots`]: super::Client::get_dexpool_snapshots*/
    #[derive(Debug, Clone)]
    pub struct GetDexpoolSnapshots<'a> {
        client: &'a super::Client,
        chain: Result<types::ChainSymbol, String>,
        pool_address: Result<::std::string::String, String>,
        cursor: Result<Option<::std::string::String>, String>,
        direction: Result<Option<types::GetDexpoolSnapshotsDirection>, String>,
        limit: Result<Option<::std::num::NonZeroU64>, String>,
        time: Result<Option<i64>, String>,
    }
    impl<'a> GetDexpoolSnapshots<'a> {
        pub fn new(client: &'a super::Client) -> Self {
            Self {
                client: client,
                chain: Err("chain was not initialized".to_string()),
                pool_address: Err("pool_address was not initialized".to_string()),
                cursor: Ok(None),
                direction: Ok(None),
                limit: Ok(None),
                time: Ok(None),
            }
        }
        pub fn chain<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::ChainSymbol>,
        {
            self.chain = value
                .try_into()
                .map_err(|_| "conversion to `ChainSymbol` for chain failed".to_string());
            self
        }
        pub fn pool_address<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.pool_address = value
                .try_into()
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for pool_address failed"
                        .to_string()
                });
            self
        }
        pub fn cursor<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.cursor = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for cursor failed"
                        .to_string()
                });
            self
        }
        pub fn direction<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::GetDexpoolSnapshotsDirection>,
        {
            self.direction = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `GetDexpoolSnapshotsDirection` for direction failed"
                        .to_string()
                });
            self
        }
        pub fn limit<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::num::NonZeroU64>,
        {
            self.limit = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: num :: NonZeroU64` for limit failed"
                        .to_string()
                });
            self
        }
        pub fn time<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<i64>,
        {
            self.time = value
                .try_into()
                .map(Some)
                .map_err(|_| "conversion to `i64` for time failed".to_string());
            self
        }
        ///Sends a `GET` request to `/v1/dexpools/{chain}/{poolAddress}/snapshots`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::DexPoolSnapshotPage>, Error<()>> {
            let Self { client, chain, pool_address, cursor, direction, limit, time } = self;
            let chain = chain.map_err(Error::InvalidRequest)?;
            let pool_address = pool_address.map_err(Error::InvalidRequest)?;
            let cursor = cursor.map_err(Error::InvalidRequest)?;
            let direction = direction.map_err(Error::InvalidRequest)?;
            let limit = limit.map_err(Error::InvalidRequest)?;
            let time = time.map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v1/dexpools/{}/{}/snapshots", client.baseurl, encode_path(& chain
                .to_string()), encode_path(& pool_address.to_string()),
            );
            let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
            header_map
                .append(
                    ::reqwest::header::HeaderName::from_static("api-version"),
                    ::reqwest::header::HeaderValue::from_static(
                        super::Client::api_version(),
                    ),
                );
            #[allow(unused_mut)]
            let mut request = client
                .client
                .get(url)
                .header(
                    ::reqwest::header::ACCEPT,
                    ::reqwest::header::HeaderValue::from_static("application/json"),
                )
                .query(&progenitor_middleware_client::QueryParam::new("cursor", &cursor))
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "direction",
                        &direction,
                    ),
                )
                .query(&progenitor_middleware_client::QueryParam::new("limit", &limit))
                .query(&progenitor_middleware_client::QueryParam::new("time", &time))
                .headers(header_map)
                .build()?;
            let info = OperationInfo {
                operation_id: "get_dexpool_snapshots",
            };
            client.pre(&mut request, &info).await?;
            let result = client.exec(request, &info).await;
            client.post(&result, &info).await?;
            let response = result?;
            match response.status().as_u16() {
                200u16 => ResponseValue::from_response::<()>(response).await,
                _ => Err(Error::UnexpectedResponse(response)),
            }
        }
    }
    /**Builder for [`Client::presign`]

[`Client::presign`]: super::Client::presign*/
    #[derive(Debug, Clone)]
    pub struct Presign<'a> {
        client: &'a super::Client,
    }
    impl<'a> Presign<'a> {
        pub fn new(client: &'a super::Client) -> Self {
            Self { client: client }
        }
        ///Sends a `POST` request to `/v1/ipfs/presign`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<::std::string::String>, Error<()>> {
            let Self { client } = self;
            let url = format!("{}/v1/ipfs/presign", client.baseurl,);
            let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
            header_map
                .append(
                    ::reqwest::header::HeaderName::from_static("api-version"),
                    ::reqwest::header::HeaderValue::from_static(
                        super::Client::api_version(),
                    ),
                );
            #[allow(unused_mut)]
            let mut request = client
                .client
                .post(url)
                .header(
                    ::reqwest::header::ACCEPT,
                    ::reqwest::header::HeaderValue::from_static("application/json"),
                )
                .headers(header_map)
                .build()?;
            let info = OperationInfo {
                operation_id: "presign",
            };
            client.pre(&mut request, &info).await?;
            let result = client.exec(request, &info).await;
            client.post(&result, &info).await?;
            let response = result?;
            match response.status().as_u16() {
                200u16 => ResponseValue::from_response::<()>(response).await,
                _ => Err(Error::UnexpectedResponse(response)),
            }
        }
    }
    /**Builder for [`Client::get`]

[`Client::get`]: super::Client::get*/
    #[derive(Debug, Clone)]
    pub struct Get<'a> {
        client: &'a super::Client,
        id: Result<::std::string::String, String>,
    }
    impl<'a> Get<'a> {
        pub fn new(client: &'a super::Client) -> Self {
            Self {
                client: client,
                id: Err("id was not initialized".to_string()),
            }
        }
        pub fn id<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.id = value
                .try_into()
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for id failed"
                        .to_string()
                });
            self
        }
        ///Sends a `GET` request to `/v1/jobs/{id}`
        pub async fn send(self) -> Result<ResponseValue<types::JobDto>, Error<()>> {
            let Self { client, id } = self;
            let id = id.map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v1/jobs/{}", client.baseurl, encode_path(& id.to_string()),
            );
            let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
            header_map
                .append(
                    ::reqwest::header::HeaderName::from_static("api-version"),
                    ::reqwest::header::HeaderValue::from_static(
                        super::Client::api_version(),
                    ),
                );
            #[allow(unused_mut)]
            let mut request = client
                .client
                .get(url)
                .header(
                    ::reqwest::header::ACCEPT,
                    ::reqwest::header::HeaderValue::from_static("application/json"),
                )
                .headers(header_map)
                .build()?;
            let info = OperationInfo {
                operation_id: "get",
            };
            client.pre(&mut request, &info).await?;
            let result = client.exec(request, &info).await;
            client.post(&result, &info).await?;
            let response = result?;
            match response.status().as_u16() {
                200u16 => ResponseValue::from_response::<()>(response).await,
                _ => Err(Error::UnexpectedResponse(response)),
            }
        }
    }
    /**Builder for [`Client::streaming`]

[`Client::streaming`]: super::Client::streaming*/
    #[derive(Debug, Clone)]
    pub struct Streaming<'a> {
        client: &'a super::Client,
        id: Result<::std::string::String, String>,
    }
    impl<'a> Streaming<'a> {
        pub fn new(client: &'a super::Client) -> Self {
            Self {
                client: client,
                id: Err("id was not initialized".to_string()),
            }
        }
        pub fn id<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.id = value
                .try_into()
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for id failed"
                        .to_string()
                });
            self
        }
        ///Sends a `GET` request to `/v1/jobs/{id}/streaming`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::JobStreamingDto>, Error<()>> {
            let Self { client, id } = self;
            let id = id.map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v1/jobs/{}/streaming", client.baseurl, encode_path(& id.to_string()),
            );
            let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
            header_map
                .append(
                    ::reqwest::header::HeaderName::from_static("api-version"),
                    ::reqwest::header::HeaderValue::from_static(
                        super::Client::api_version(),
                    ),
                );
            #[allow(unused_mut)]
            let mut request = client
                .client
                .get(url)
                .header(
                    ::reqwest::header::ACCEPT,
                    ::reqwest::header::HeaderValue::from_static("application/json"),
                )
                .headers(header_map)
                .build()?;
            let info = OperationInfo {
                operation_id: "streaming",
            };
            client.pre(&mut request, &info).await?;
            let result = client.exec(request, &info).await;
            client.post(&result, &info).await?;
            let response = result?;
            match response.status().as_u16() {
                200u16 => ResponseValue::from_response::<()>(response).await,
                _ => Err(Error::UnexpectedResponse(response)),
            }
        }
    }
    /**Builder for [`Client::register_address`]

[`Client::register_address`]: super::Client::register_address*/
    #[derive(Debug, Clone)]
    pub struct RegisterAddress<'a> {
        client: &'a super::Client,
        body: Result<types::builder::RegisterAddressRequest, String>,
    }
    impl<'a> RegisterAddress<'a> {
        pub fn new(client: &'a super::Client) -> Self {
            Self {
                client: client,
                body: Ok(::std::default::Default::default()),
            }
        }
        pub fn body<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::RegisterAddressRequest>,
            <V as std::convert::TryInto<
                types::RegisterAddressRequest,
            >>::Error: std::fmt::Display,
        {
            self.body = value
                .try_into()
                .map(From::from)
                .map_err(|s| {
                    format!(
                        "conversion to `RegisterAddressRequest` for body failed: {}", s
                    )
                });
            self
        }
        pub fn body_map<F>(mut self, f: F) -> Self
        where
            F: std::ops::FnOnce(
                types::builder::RegisterAddressRequest,
            ) -> types::builder::RegisterAddressRequest,
        {
            self.body = self.body.map(f);
            self
        }
        ///Sends a `POST` request to `/v1/kyt/address`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::RegisterAddressResponseDto>, Error<()>> {
            let Self { client, body } = self;
            let body = body
                .and_then(|v| {
                    types::RegisterAddressRequest::try_from(v).map_err(|e| e.to_string())
                })
                .map_err(Error::InvalidRequest)?;
            let url = format!("{}/v1/kyt/address", client.baseurl,);
            let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
            header_map
                .append(
                    ::reqwest::header::HeaderName::from_static("api-version"),
                    ::reqwest::header::HeaderValue::from_static(
                        super::Client::api_version(),
                    ),
                );
            #[allow(unused_mut)]
            let mut request = client
                .client
                .post(url)
                .header(
                    ::reqwest::header::ACCEPT,
                    ::reqwest::header::HeaderValue::from_static("application/json"),
                )
                .json(&body)
                .headers(header_map)
                .build()?;
            let info = OperationInfo {
                operation_id: "register_address",
            };
            client.pre(&mut request, &info).await?;
            let result = client.exec(request, &info).await;
            client.post(&result, &info).await?;
            let response = result?;
            match response.status().as_u16() {
                200u16 => ResponseValue::from_response::<()>(response).await,
                _ => Err(Error::UnexpectedResponse(response)),
            }
        }
    }
    /**Builder for [`Client::get_address_risk`]

[`Client::get_address_risk`]: super::Client::get_address_risk*/
    #[derive(Debug, Clone)]
    pub struct GetAddressRisk<'a> {
        client: &'a super::Client,
        address: Result<::std::string::String, String>,
    }
    impl<'a> GetAddressRisk<'a> {
        pub fn new(client: &'a super::Client) -> Self {
            Self {
                client: client,
                address: Err("address was not initialized".to_string()),
            }
        }
        pub fn address<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.address = value
                .try_into()
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for address failed"
                        .to_string()
                });
            self
        }
        ///Sends a `GET` request to `/v1/kyt/addresses/{address}/risk`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::AddressRiskResponseDto>, Error<()>> {
            let Self { client, address } = self;
            let address = address.map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v1/kyt/addresses/{}/risk", client.baseurl, encode_path(& address
                .to_string()),
            );
            let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
            header_map
                .append(
                    ::reqwest::header::HeaderName::from_static("api-version"),
                    ::reqwest::header::HeaderValue::from_static(
                        super::Client::api_version(),
                    ),
                );
            #[allow(unused_mut)]
            let mut request = client
                .client
                .get(url)
                .header(
                    ::reqwest::header::ACCEPT,
                    ::reqwest::header::HeaderValue::from_static("application/json"),
                )
                .headers(header_map)
                .build()?;
            let info = OperationInfo {
                operation_id: "get_address_risk",
            };
            client.pre(&mut request, &info).await?;
            let result = client.exec(request, &info).await;
            client.post(&result, &info).await?;
            let response = result?;
            match response.status().as_u16() {
                200u16 => ResponseValue::from_response::<()>(response).await,
                _ => Err(Error::UnexpectedResponse(response)),
            }
        }
    }
    /**Builder for [`Client::register_transfer`]

[`Client::register_transfer`]: super::Client::register_transfer*/
    #[derive(Debug, Clone)]
    pub struct RegisterTransfer<'a> {
        client: &'a super::Client,
        body: Result<types::builder::KytRegisterTransferRequest, String>,
    }
    impl<'a> RegisterTransfer<'a> {
        pub fn new(client: &'a super::Client) -> Self {
            Self {
                client: client,
                body: Ok(::std::default::Default::default()),
            }
        }
        pub fn body<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::KytRegisterTransferRequest>,
            <V as std::convert::TryInto<
                types::KytRegisterTransferRequest,
            >>::Error: std::fmt::Display,
        {
            self.body = value
                .try_into()
                .map(From::from)
                .map_err(|s| {
                    format!(
                        "conversion to `KytRegisterTransferRequest` for body failed: {}",
                        s
                    )
                });
            self
        }
        pub fn body_map<F>(mut self, f: F) -> Self
        where
            F: std::ops::FnOnce(
                types::builder::KytRegisterTransferRequest,
            ) -> types::builder::KytRegisterTransferRequest,
        {
            self.body = self.body.map(f);
            self
        }
        ///Sends a `POST` request to `/v1/kyt/transfer`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::TransferBaseResponseDto>, Error<()>> {
            let Self { client, body } = self;
            let body = body
                .and_then(|v| {
                    types::KytRegisterTransferRequest::try_from(v)
                        .map_err(|e| e.to_string())
                })
                .map_err(Error::InvalidRequest)?;
            let url = format!("{}/v1/kyt/transfer", client.baseurl,);
            let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
            header_map
                .append(
                    ::reqwest::header::HeaderName::from_static("api-version"),
                    ::reqwest::header::HeaderValue::from_static(
                        super::Client::api_version(),
                    ),
                );
            #[allow(unused_mut)]
            let mut request = client
                .client
                .post(url)
                .header(
                    ::reqwest::header::ACCEPT,
                    ::reqwest::header::HeaderValue::from_static("application/json"),
                )
                .json(&body)
                .headers(header_map)
                .build()?;
            let info = OperationInfo {
                operation_id: "register_transfer",
            };
            client.pre(&mut request, &info).await?;
            let result = client.exec(request, &info).await;
            client.post(&result, &info).await?;
            let response = result?;
            match response.status().as_u16() {
                200u16 => ResponseValue::from_response::<()>(response).await,
                _ => Err(Error::UnexpectedResponse(response)),
            }
        }
    }
    /**Builder for [`Client::get_transfer_alerts`]

[`Client::get_transfer_alerts`]: super::Client::get_transfer_alerts*/
    #[derive(Debug, Clone)]
    pub struct GetTransferAlerts<'a> {
        client: &'a super::Client,
        transfer_id: Result<::std::string::String, String>,
    }
    impl<'a> GetTransferAlerts<'a> {
        pub fn new(client: &'a super::Client) -> Self {
            Self {
                client: client,
                transfer_id: Err("transfer_id was not initialized".to_string()),
            }
        }
        pub fn transfer_id<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.transfer_id = value
                .try_into()
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for transfer_id failed"
                        .to_string()
                });
            self
        }
        ///Sends a `GET` request to `/v1/kyt/transfers/{transferId}/alerts`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::TransferAlertsResponseDto>, Error<()>> {
            let Self { client, transfer_id } = self;
            let transfer_id = transfer_id.map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v1/kyt/transfers/{}/alerts", client.baseurl, encode_path(&
                transfer_id.to_string()),
            );
            let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
            header_map
                .append(
                    ::reqwest::header::HeaderName::from_static("api-version"),
                    ::reqwest::header::HeaderValue::from_static(
                        super::Client::api_version(),
                    ),
                );
            #[allow(unused_mut)]
            let mut request = client
                .client
                .get(url)
                .header(
                    ::reqwest::header::ACCEPT,
                    ::reqwest::header::HeaderValue::from_static("application/json"),
                )
                .headers(header_map)
                .build()?;
            let info = OperationInfo {
                operation_id: "get_transfer_alerts",
            };
            client.pre(&mut request, &info).await?;
            let result = client.exec(request, &info).await;
            client.post(&result, &info).await?;
            let response = result?;
            match response.status().as_u16() {
                200u16 => ResponseValue::from_response::<()>(response).await,
                _ => Err(Error::UnexpectedResponse(response)),
            }
        }
    }
    /**Builder for [`Client::get_transfer_direct_exposure`]

[`Client::get_transfer_direct_exposure`]: super::Client::get_transfer_direct_exposure*/
    #[derive(Debug, Clone)]
    pub struct GetTransferDirectExposure<'a> {
        client: &'a super::Client,
        transfer_id: Result<::std::string::String, String>,
    }
    impl<'a> GetTransferDirectExposure<'a> {
        pub fn new(client: &'a super::Client) -> Self {
            Self {
                client: client,
                transfer_id: Err("transfer_id was not initialized".to_string()),
            }
        }
        pub fn transfer_id<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.transfer_id = value
                .try_into()
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for transfer_id failed"
                        .to_string()
                });
            self
        }
        ///Sends a `GET` request to `/v1/kyt/transfers/{transferId}/exposures/direct`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::TransferDirectExposureResponseDto>, Error<()>> {
            let Self { client, transfer_id } = self;
            let transfer_id = transfer_id.map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v1/kyt/transfers/{}/exposures/direct", client.baseurl, encode_path(&
                transfer_id.to_string()),
            );
            let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
            header_map
                .append(
                    ::reqwest::header::HeaderName::from_static("api-version"),
                    ::reqwest::header::HeaderValue::from_static(
                        super::Client::api_version(),
                    ),
                );
            #[allow(unused_mut)]
            let mut request = client
                .client
                .get(url)
                .header(
                    ::reqwest::header::ACCEPT,
                    ::reqwest::header::HeaderValue::from_static("application/json"),
                )
                .headers(header_map)
                .build()?;
            let info = OperationInfo {
                operation_id: "get_transfer_direct_exposure",
            };
            client.pre(&mut request, &info).await?;
            let result = client.exec(request, &info).await;
            client.post(&result, &info).await?;
            let response = result?;
            match response.status().as_u16() {
                200u16 => ResponseValue::from_response::<()>(response).await,
                _ => Err(Error::UnexpectedResponse(response)),
            }
        }
    }
    /**Builder for [`Client::get_transfer_network_identifications`]

[`Client::get_transfer_network_identifications`]: super::Client::get_transfer_network_identifications*/
    #[derive(Debug, Clone)]
    pub struct GetTransferNetworkIdentifications<'a> {
        client: &'a super::Client,
        transfer_id: Result<::std::string::String, String>,
    }
    impl<'a> GetTransferNetworkIdentifications<'a> {
        pub fn new(client: &'a super::Client) -> Self {
            Self {
                client: client,
                transfer_id: Err("transfer_id was not initialized".to_string()),
            }
        }
        pub fn transfer_id<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.transfer_id = value
                .try_into()
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for transfer_id failed"
                        .to_string()
                });
            self
        }
        ///Sends a `GET` request to `/v1/kyt/transfers/{transferId}/network-identifications`
        pub async fn send(
            self,
        ) -> Result<
            ResponseValue<types::TransferNetworkIdentificationsResponseDto>,
            Error<()>,
        > {
            let Self { client, transfer_id } = self;
            let transfer_id = transfer_id.map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v1/kyt/transfers/{}/network-identifications", client.baseurl,
                encode_path(& transfer_id.to_string()),
            );
            let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
            header_map
                .append(
                    ::reqwest::header::HeaderName::from_static("api-version"),
                    ::reqwest::header::HeaderValue::from_static(
                        super::Client::api_version(),
                    ),
                );
            #[allow(unused_mut)]
            let mut request = client
                .client
                .get(url)
                .header(
                    ::reqwest::header::ACCEPT,
                    ::reqwest::header::HeaderValue::from_static("application/json"),
                )
                .headers(header_map)
                .build()?;
            let info = OperationInfo {
                operation_id: "get_transfer_network_identifications",
            };
            client.pre(&mut request, &info).await?;
            let result = client.exec(request, &info).await;
            client.post(&result, &info).await?;
            let response = result?;
            match response.status().as_u16() {
                200u16 => ResponseValue::from_response::<()>(response).await,
                _ => Err(Error::UnexpectedResponse(response)),
            }
        }
    }
    /**Builder for [`Client::get_transfer_summary`]

[`Client::get_transfer_summary`]: super::Client::get_transfer_summary*/
    #[derive(Debug, Clone)]
    pub struct GetTransferSummary<'a> {
        client: &'a super::Client,
        transfer_id: Result<::std::string::String, String>,
    }
    impl<'a> GetTransferSummary<'a> {
        pub fn new(client: &'a super::Client) -> Self {
            Self {
                client: client,
                transfer_id: Err("transfer_id was not initialized".to_string()),
            }
        }
        pub fn transfer_id<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.transfer_id = value
                .try_into()
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for transfer_id failed"
                        .to_string()
                });
            self
        }
        ///Sends a `GET` request to `/v1/kyt/transfers/{transferId}/summary`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::TransferBaseResponseDto>, Error<()>> {
            let Self { client, transfer_id } = self;
            let transfer_id = transfer_id.map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v1/kyt/transfers/{}/summary", client.baseurl, encode_path(&
                transfer_id.to_string()),
            );
            let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
            header_map
                .append(
                    ::reqwest::header::HeaderName::from_static("api-version"),
                    ::reqwest::header::HeaderValue::from_static(
                        super::Client::api_version(),
                    ),
                );
            #[allow(unused_mut)]
            let mut request = client
                .client
                .get(url)
                .header(
                    ::reqwest::header::ACCEPT,
                    ::reqwest::header::HeaderValue::from_static("application/json"),
                )
                .headers(header_map)
                .build()?;
            let info = OperationInfo {
                operation_id: "get_transfer_summary",
            };
            client.pre(&mut request, &info).await?;
            let result = client.exec(request, &info).await;
            client.post(&result, &info).await?;
            let response = result?;
            match response.status().as_u16() {
                200u16 => ResponseValue::from_response::<()>(response).await,
                _ => Err(Error::UnexpectedResponse(response)),
            }
        }
    }
    /**Builder for [`Client::register_withdrawal`]

[`Client::register_withdrawal`]: super::Client::register_withdrawal*/
    #[derive(Debug, Clone)]
    pub struct RegisterWithdrawal<'a> {
        client: &'a super::Client,
        body: Result<types::builder::KytRegisterWithdrawalRequest, String>,
    }
    impl<'a> RegisterWithdrawal<'a> {
        pub fn new(client: &'a super::Client) -> Self {
            Self {
                client: client,
                body: Ok(::std::default::Default::default()),
            }
        }
        pub fn body<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::KytRegisterWithdrawalRequest>,
            <V as std::convert::TryInto<
                types::KytRegisterWithdrawalRequest,
            >>::Error: std::fmt::Display,
        {
            self.body = value
                .try_into()
                .map(From::from)
                .map_err(|s| {
                    format!(
                        "conversion to `KytRegisterWithdrawalRequest` for body failed: {}",
                        s
                    )
                });
            self
        }
        pub fn body_map<F>(mut self, f: F) -> Self
        where
            F: std::ops::FnOnce(
                types::builder::KytRegisterWithdrawalRequest,
            ) -> types::builder::KytRegisterWithdrawalRequest,
        {
            self.body = self.body.map(f);
            self
        }
        ///Sends a `POST` request to `/v1/kyt/withdrawal`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::WithdrawalBaseResponseDto>, Error<()>> {
            let Self { client, body } = self;
            let body = body
                .and_then(|v| {
                    types::KytRegisterWithdrawalRequest::try_from(v)
                        .map_err(|e| e.to_string())
                })
                .map_err(Error::InvalidRequest)?;
            let url = format!("{}/v1/kyt/withdrawal", client.baseurl,);
            let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
            header_map
                .append(
                    ::reqwest::header::HeaderName::from_static("api-version"),
                    ::reqwest::header::HeaderValue::from_static(
                        super::Client::api_version(),
                    ),
                );
            #[allow(unused_mut)]
            let mut request = client
                .client
                .post(url)
                .header(
                    ::reqwest::header::ACCEPT,
                    ::reqwest::header::HeaderValue::from_static("application/json"),
                )
                .json(&body)
                .headers(header_map)
                .build()?;
            let info = OperationInfo {
                operation_id: "register_withdrawal",
            };
            client.pre(&mut request, &info).await?;
            let result = client.exec(request, &info).await;
            client.post(&result, &info).await?;
            let response = result?;
            match response.status().as_u16() {
                200u16 => ResponseValue::from_response::<()>(response).await,
                _ => Err(Error::UnexpectedResponse(response)),
            }
        }
    }
    /**Builder for [`Client::get_withdrawal_address_identifications`]

[`Client::get_withdrawal_address_identifications`]: super::Client::get_withdrawal_address_identifications*/
    #[derive(Debug, Clone)]
    pub struct GetWithdrawalAddressIdentifications<'a> {
        client: &'a super::Client,
        withdrawal_id: Result<::std::string::String, String>,
    }
    impl<'a> GetWithdrawalAddressIdentifications<'a> {
        pub fn new(client: &'a super::Client) -> Self {
            Self {
                client: client,
                withdrawal_id: Err("withdrawal_id was not initialized".to_string()),
            }
        }
        pub fn withdrawal_id<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.withdrawal_id = value
                .try_into()
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for withdrawal_id failed"
                        .to_string()
                });
            self
        }
        ///Sends a `GET` request to `/v1/kyt/withdrawal/{withdrawalId}/address-identifications`
        pub async fn send(
            self,
        ) -> Result<
            ResponseValue<types::WithdrawalAddressIdentificationsResponseDto>,
            Error<()>,
        > {
            let Self { client, withdrawal_id } = self;
            let withdrawal_id = withdrawal_id.map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v1/kyt/withdrawal/{}/address-identifications", client.baseurl,
                encode_path(& withdrawal_id.to_string()),
            );
            let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
            header_map
                .append(
                    ::reqwest::header::HeaderName::from_static("api-version"),
                    ::reqwest::header::HeaderValue::from_static(
                        super::Client::api_version(),
                    ),
                );
            #[allow(unused_mut)]
            let mut request = client
                .client
                .get(url)
                .header(
                    ::reqwest::header::ACCEPT,
                    ::reqwest::header::HeaderValue::from_static("application/json"),
                )
                .headers(header_map)
                .build()?;
            let info = OperationInfo {
                operation_id: "get_withdrawal_address_identifications",
            };
            client.pre(&mut request, &info).await?;
            let result = client.exec(request, &info).await;
            client.post(&result, &info).await?;
            let response = result?;
            match response.status().as_u16() {
                200u16 => ResponseValue::from_response::<()>(response).await,
                _ => Err(Error::UnexpectedResponse(response)),
            }
        }
    }
    /**Builder for [`Client::get_withdrawal_alerts`]

[`Client::get_withdrawal_alerts`]: super::Client::get_withdrawal_alerts*/
    #[derive(Debug, Clone)]
    pub struct GetWithdrawalAlerts<'a> {
        client: &'a super::Client,
        withdrawal_id: Result<::std::string::String, String>,
    }
    impl<'a> GetWithdrawalAlerts<'a> {
        pub fn new(client: &'a super::Client) -> Self {
            Self {
                client: client,
                withdrawal_id: Err("withdrawal_id was not initialized".to_string()),
            }
        }
        pub fn withdrawal_id<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.withdrawal_id = value
                .try_into()
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for withdrawal_id failed"
                        .to_string()
                });
            self
        }
        ///Sends a `GET` request to `/v1/kyt/withdrawal/{withdrawalId}/alerts`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::TransferAlertsResponseDto>, Error<()>> {
            let Self { client, withdrawal_id } = self;
            let withdrawal_id = withdrawal_id.map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v1/kyt/withdrawal/{}/alerts", client.baseurl, encode_path(&
                withdrawal_id.to_string()),
            );
            let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
            header_map
                .append(
                    ::reqwest::header::HeaderName::from_static("api-version"),
                    ::reqwest::header::HeaderValue::from_static(
                        super::Client::api_version(),
                    ),
                );
            #[allow(unused_mut)]
            let mut request = client
                .client
                .get(url)
                .header(
                    ::reqwest::header::ACCEPT,
                    ::reqwest::header::HeaderValue::from_static("application/json"),
                )
                .headers(header_map)
                .build()?;
            let info = OperationInfo {
                operation_id: "get_withdrawal_alerts",
            };
            client.pre(&mut request, &info).await?;
            let result = client.exec(request, &info).await;
            client.post(&result, &info).await?;
            let response = result?;
            match response.status().as_u16() {
                200u16 => ResponseValue::from_response::<()>(response).await,
                _ => Err(Error::UnexpectedResponse(response)),
            }
        }
    }
    /**Builder for [`Client::get_withdrawal_direct_exposure`]

[`Client::get_withdrawal_direct_exposure`]: super::Client::get_withdrawal_direct_exposure*/
    #[derive(Debug, Clone)]
    pub struct GetWithdrawalDirectExposure<'a> {
        client: &'a super::Client,
        withdrawal_id: Result<::std::string::String, String>,
    }
    impl<'a> GetWithdrawalDirectExposure<'a> {
        pub fn new(client: &'a super::Client) -> Self {
            Self {
                client: client,
                withdrawal_id: Err("withdrawal_id was not initialized".to_string()),
            }
        }
        pub fn withdrawal_id<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.withdrawal_id = value
                .try_into()
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for withdrawal_id failed"
                        .to_string()
                });
            self
        }
        ///Sends a `GET` request to `/v1/kyt/withdrawal/{withdrawalId}/exposures/direct`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::TransferDirectExposureResponseDto>, Error<()>> {
            let Self { client, withdrawal_id } = self;
            let withdrawal_id = withdrawal_id.map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v1/kyt/withdrawal/{}/exposures/direct", client.baseurl, encode_path(&
                withdrawal_id.to_string()),
            );
            let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
            header_map
                .append(
                    ::reqwest::header::HeaderName::from_static("api-version"),
                    ::reqwest::header::HeaderValue::from_static(
                        super::Client::api_version(),
                    ),
                );
            #[allow(unused_mut)]
            let mut request = client
                .client
                .get(url)
                .header(
                    ::reqwest::header::ACCEPT,
                    ::reqwest::header::HeaderValue::from_static("application/json"),
                )
                .headers(header_map)
                .build()?;
            let info = OperationInfo {
                operation_id: "get_withdrawal_direct_exposure",
            };
            client.pre(&mut request, &info).await?;
            let result = client.exec(request, &info).await;
            client.post(&result, &info).await?;
            let response = result?;
            match response.status().as_u16() {
                200u16 => ResponseValue::from_response::<()>(response).await,
                _ => Err(Error::UnexpectedResponse(response)),
            }
        }
    }
    /**Builder for [`Client::get_withdrawal_fraud_assessment`]

[`Client::get_withdrawal_fraud_assessment`]: super::Client::get_withdrawal_fraud_assessment*/
    #[derive(Debug, Clone)]
    pub struct GetWithdrawalFraudAssessment<'a> {
        client: &'a super::Client,
        withdrawal_id: Result<::std::string::String, String>,
    }
    impl<'a> GetWithdrawalFraudAssessment<'a> {
        pub fn new(client: &'a super::Client) -> Self {
            Self {
                client: client,
                withdrawal_id: Err("withdrawal_id was not initialized".to_string()),
            }
        }
        pub fn withdrawal_id<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.withdrawal_id = value
                .try_into()
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for withdrawal_id failed"
                        .to_string()
                });
            self
        }
        ///Sends a `GET` request to `/v1/kyt/withdrawal/{withdrawalId}/fraud-assessment`
        pub async fn send(
            self,
        ) -> Result<
            ResponseValue<types::WithdrawalFraudAssessmentResponseDto>,
            Error<()>,
        > {
            let Self { client, withdrawal_id } = self;
            let withdrawal_id = withdrawal_id.map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v1/kyt/withdrawal/{}/fraud-assessment", client.baseurl, encode_path(&
                withdrawal_id.to_string()),
            );
            let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
            header_map
                .append(
                    ::reqwest::header::HeaderName::from_static("api-version"),
                    ::reqwest::header::HeaderValue::from_static(
                        super::Client::api_version(),
                    ),
                );
            #[allow(unused_mut)]
            let mut request = client
                .client
                .get(url)
                .header(
                    ::reqwest::header::ACCEPT,
                    ::reqwest::header::HeaderValue::from_static("application/json"),
                )
                .headers(header_map)
                .build()?;
            let info = OperationInfo {
                operation_id: "get_withdrawal_fraud_assessment",
            };
            client.pre(&mut request, &info).await?;
            let result = client.exec(request, &info).await;
            client.post(&result, &info).await?;
            let response = result?;
            match response.status().as_u16() {
                200u16 => ResponseValue::from_response::<()>(response).await,
                _ => Err(Error::UnexpectedResponse(response)),
            }
        }
    }
    /**Builder for [`Client::get_withdrawal_network_identifications`]

[`Client::get_withdrawal_network_identifications`]: super::Client::get_withdrawal_network_identifications*/
    #[derive(Debug, Clone)]
    pub struct GetWithdrawalNetworkIdentifications<'a> {
        client: &'a super::Client,
        withdrawal_id: Result<::std::string::String, String>,
    }
    impl<'a> GetWithdrawalNetworkIdentifications<'a> {
        pub fn new(client: &'a super::Client) -> Self {
            Self {
                client: client,
                withdrawal_id: Err("withdrawal_id was not initialized".to_string()),
            }
        }
        pub fn withdrawal_id<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.withdrawal_id = value
                .try_into()
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for withdrawal_id failed"
                        .to_string()
                });
            self
        }
        ///Sends a `GET` request to `/v1/kyt/withdrawal/{withdrawalId}/network-identifications`
        pub async fn send(
            self,
        ) -> Result<
            ResponseValue<types::TransferNetworkIdentificationsResponseDto>,
            Error<()>,
        > {
            let Self { client, withdrawal_id } = self;
            let withdrawal_id = withdrawal_id.map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v1/kyt/withdrawal/{}/network-identifications", client.baseurl,
                encode_path(& withdrawal_id.to_string()),
            );
            let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
            header_map
                .append(
                    ::reqwest::header::HeaderName::from_static("api-version"),
                    ::reqwest::header::HeaderValue::from_static(
                        super::Client::api_version(),
                    ),
                );
            #[allow(unused_mut)]
            let mut request = client
                .client
                .get(url)
                .header(
                    ::reqwest::header::ACCEPT,
                    ::reqwest::header::HeaderValue::from_static("application/json"),
                )
                .headers(header_map)
                .build()?;
            let info = OperationInfo {
                operation_id: "get_withdrawal_network_identifications",
            };
            client.pre(&mut request, &info).await?;
            let result = client.exec(request, &info).await;
            client.post(&result, &info).await?;
            let response = result?;
            match response.status().as_u16() {
                200u16 => ResponseValue::from_response::<()>(response).await,
                _ => Err(Error::UnexpectedResponse(response)),
            }
        }
    }
    /**Builder for [`Client::get_withdrawal_summary`]

[`Client::get_withdrawal_summary`]: super::Client::get_withdrawal_summary*/
    #[derive(Debug, Clone)]
    pub struct GetWithdrawalSummary<'a> {
        client: &'a super::Client,
        withdrawal_id: Result<::std::string::String, String>,
    }
    impl<'a> GetWithdrawalSummary<'a> {
        pub fn new(client: &'a super::Client) -> Self {
            Self {
                client: client,
                withdrawal_id: Err("withdrawal_id was not initialized".to_string()),
            }
        }
        pub fn withdrawal_id<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.withdrawal_id = value
                .try_into()
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for withdrawal_id failed"
                        .to_string()
                });
            self
        }
        ///Sends a `GET` request to `/v1/kyt/withdrawal/{withdrawalId}/summary`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::WithdrawalBaseResponseDto>, Error<()>> {
            let Self { client, withdrawal_id } = self;
            let withdrawal_id = withdrawal_id.map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v1/kyt/withdrawal/{}/summary", client.baseurl, encode_path(&
                withdrawal_id.to_string()),
            );
            let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
            header_map
                .append(
                    ::reqwest::header::HeaderName::from_static("api-version"),
                    ::reqwest::header::HeaderValue::from_static(
                        super::Client::api_version(),
                    ),
                );
            #[allow(unused_mut)]
            let mut request = client
                .client
                .get(url)
                .header(
                    ::reqwest::header::ACCEPT,
                    ::reqwest::header::HeaderValue::from_static("application/json"),
                )
                .headers(header_map)
                .build()?;
            let info = OperationInfo {
                operation_id: "get_withdrawal_summary",
            };
            client.pre(&mut request, &info).await?;
            let result = client.exec(request, &info).await;
            client.post(&result, &info).await?;
            let response = result?;
            match response.status().as_u16() {
                200u16 => ResponseValue::from_response::<()>(response).await,
                _ => Err(Error::UnexpectedResponse(response)),
            }
        }
    }
    /**Builder for [`Client::get_final_stretch_tokens`]

[`Client::get_final_stretch_tokens`]: super::Client::get_final_stretch_tokens*/
    #[derive(Debug, Clone)]
    pub struct GetFinalStretchTokens<'a> {
        client: &'a super::Client,
        chain: Result<types::ChainSymbol, String>,
        exclude_keywords: Result<Option<::std::vec::Vec<::std::string::String>>, String>,
        filters: Result<Option<::std::vec::Vec<::std::string::String>>, String>,
        launchpad_platform: Result<
            Option<::std::vec::Vec<::std::string::String>>,
            String,
        >,
        range_filters: Result<Option<::std::vec::Vec<types::FilterCondition>>, String>,
        search_keywords: Result<Option<::std::vec::Vec<::std::string::String>>, String>,
        sort_by: Result<Option<types::GetFinalStretchTokensSortBy>, String>,
        sort_direction: Result<
            Option<types::GetFinalStretchTokensSortDirection>,
            String,
        >,
        tag: Result<Option<types::GetFinalStretchTokensTag>, String>,
    }
    impl<'a> GetFinalStretchTokens<'a> {
        pub fn new(client: &'a super::Client) -> Self {
            Self {
                client: client,
                chain: Err("chain was not initialized".to_string()),
                exclude_keywords: Ok(None),
                filters: Ok(None),
                launchpad_platform: Ok(None),
                range_filters: Ok(None),
                search_keywords: Ok(None),
                sort_by: Ok(None),
                sort_direction: Ok(None),
                tag: Ok(None),
            }
        }
        pub fn chain<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::ChainSymbol>,
        {
            self.chain = value
                .try_into()
                .map_err(|_| "conversion to `ChainSymbol` for chain failed".to_string());
            self
        }
        pub fn exclude_keywords<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::vec::Vec<::std::string::String>>,
        {
            self.exclude_keywords = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: vec :: Vec < :: std :: string :: String >` for exclude_keywords failed"
                        .to_string()
                });
            self
        }
        pub fn filters<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::vec::Vec<::std::string::String>>,
        {
            self.filters = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: vec :: Vec < :: std :: string :: String >` for filters failed"
                        .to_string()
                });
            self
        }
        pub fn launchpad_platform<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::vec::Vec<::std::string::String>>,
        {
            self.launchpad_platform = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: vec :: Vec < :: std :: string :: String >` for launchpad_platform failed"
                        .to_string()
                });
            self
        }
        pub fn range_filters<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::vec::Vec<types::FilterCondition>>,
        {
            self.range_filters = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: vec :: Vec < FilterCondition >` for range_filters failed"
                        .to_string()
                });
            self
        }
        pub fn search_keywords<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::vec::Vec<::std::string::String>>,
        {
            self.search_keywords = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: vec :: Vec < :: std :: string :: String >` for search_keywords failed"
                        .to_string()
                });
            self
        }
        pub fn sort_by<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::GetFinalStretchTokensSortBy>,
        {
            self.sort_by = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `GetFinalStretchTokensSortBy` for sort_by failed"
                        .to_string()
                });
            self
        }
        pub fn sort_direction<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::GetFinalStretchTokensSortDirection>,
        {
            self.sort_direction = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `GetFinalStretchTokensSortDirection` for sort_direction failed"
                        .to_string()
                });
            self
        }
        pub fn tag<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::GetFinalStretchTokensTag>,
        {
            self.tag = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `GetFinalStretchTokensTag` for tag failed".to_string()
                });
            self
        }
        ///Sends a `GET` request to `/v1/ranking/{chain}/finalStretch`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<::std::vec::Vec<types::Token>>, Error<()>> {
            let Self {
                client,
                chain,
                exclude_keywords,
                filters,
                launchpad_platform,
                range_filters,
                search_keywords,
                sort_by,
                sort_direction,
                tag,
            } = self;
            let chain = chain.map_err(Error::InvalidRequest)?;
            let exclude_keywords = exclude_keywords.map_err(Error::InvalidRequest)?;
            let filters = filters.map_err(Error::InvalidRequest)?;
            let launchpad_platform = launchpad_platform.map_err(Error::InvalidRequest)?;
            let range_filters = range_filters.map_err(Error::InvalidRequest)?;
            let search_keywords = search_keywords.map_err(Error::InvalidRequest)?;
            let sort_by = sort_by.map_err(Error::InvalidRequest)?;
            let sort_direction = sort_direction.map_err(Error::InvalidRequest)?;
            let tag = tag.map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v1/ranking/{}/finalStretch", client.baseurl, encode_path(& chain
                .to_string()),
            );
            let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
            header_map
                .append(
                    ::reqwest::header::HeaderName::from_static("api-version"),
                    ::reqwest::header::HeaderValue::from_static(
                        super::Client::api_version(),
                    ),
                );
            #[allow(unused_mut)]
            let mut request = client
                .client
                .get(url)
                .header(
                    ::reqwest::header::ACCEPT,
                    ::reqwest::header::HeaderValue::from_static("application/json"),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "excludeKeywords",
                        &exclude_keywords,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new("filters", &filters),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "launchpadPlatform",
                        &launchpad_platform,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "rangeFilters",
                        &range_filters,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "searchKeywords",
                        &search_keywords,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new("sortBy", &sort_by),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "sortDirection",
                        &sort_direction,
                    ),
                )
                .query(&progenitor_middleware_client::QueryParam::new("tag", &tag))
                .headers(header_map)
                .build()?;
            let info = OperationInfo {
                operation_id: "get_final_stretch_tokens",
            };
            client.pre(&mut request, &info).await?;
            let result = client.exec(request, &info).await;
            client.post(&result, &info).await?;
            let response = result?;
            match response.status().as_u16() {
                200u16 => ResponseValue::from_response::<()>(response).await,
                _ => Err(Error::UnexpectedResponse(response)),
            }
        }
    }
    /**Builder for [`Client::get_hot_tokens`]

[`Client::get_hot_tokens`]: super::Client::get_hot_tokens*/
    #[derive(Debug, Clone)]
    pub struct GetHotTokens<'a> {
        client: &'a super::Client,
        chain: Result<types::ChainSymbol, String>,
        duration: Result<types::GetHotTokensDuration, String>,
        exclude_keywords: Result<Option<::std::vec::Vec<::std::string::String>>, String>,
        filters: Result<Option<::std::vec::Vec<::std::string::String>>, String>,
        launchpad_platform: Result<
            Option<::std::vec::Vec<::std::string::String>>,
            String,
        >,
        range_filters: Result<Option<::std::vec::Vec<types::FilterCondition>>, String>,
        search_keywords: Result<Option<::std::vec::Vec<::std::string::String>>, String>,
        sort_by: Result<Option<types::GetHotTokensSortBy>, String>,
        sort_direction: Result<Option<types::GetHotTokensSortDirection>, String>,
        tag: Result<Option<types::GetHotTokensTag>, String>,
    }
    impl<'a> GetHotTokens<'a> {
        pub fn new(client: &'a super::Client) -> Self {
            Self {
                client: client,
                chain: Err("chain was not initialized".to_string()),
                duration: Err("duration was not initialized".to_string()),
                exclude_keywords: Ok(None),
                filters: Ok(None),
                launchpad_platform: Ok(None),
                range_filters: Ok(None),
                search_keywords: Ok(None),
                sort_by: Ok(None),
                sort_direction: Ok(None),
                tag: Ok(None),
            }
        }
        pub fn chain<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::ChainSymbol>,
        {
            self.chain = value
                .try_into()
                .map_err(|_| "conversion to `ChainSymbol` for chain failed".to_string());
            self
        }
        pub fn duration<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::GetHotTokensDuration>,
        {
            self.duration = value
                .try_into()
                .map_err(|_| {
                    "conversion to `GetHotTokensDuration` for duration failed"
                        .to_string()
                });
            self
        }
        pub fn exclude_keywords<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::vec::Vec<::std::string::String>>,
        {
            self.exclude_keywords = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: vec :: Vec < :: std :: string :: String >` for exclude_keywords failed"
                        .to_string()
                });
            self
        }
        pub fn filters<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::vec::Vec<::std::string::String>>,
        {
            self.filters = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: vec :: Vec < :: std :: string :: String >` for filters failed"
                        .to_string()
                });
            self
        }
        pub fn launchpad_platform<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::vec::Vec<::std::string::String>>,
        {
            self.launchpad_platform = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: vec :: Vec < :: std :: string :: String >` for launchpad_platform failed"
                        .to_string()
                });
            self
        }
        pub fn range_filters<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::vec::Vec<types::FilterCondition>>,
        {
            self.range_filters = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: vec :: Vec < FilterCondition >` for range_filters failed"
                        .to_string()
                });
            self
        }
        pub fn search_keywords<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::vec::Vec<::std::string::String>>,
        {
            self.search_keywords = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: vec :: Vec < :: std :: string :: String >` for search_keywords failed"
                        .to_string()
                });
            self
        }
        pub fn sort_by<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::GetHotTokensSortBy>,
        {
            self.sort_by = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `GetHotTokensSortBy` for sort_by failed".to_string()
                });
            self
        }
        pub fn sort_direction<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::GetHotTokensSortDirection>,
        {
            self.sort_direction = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `GetHotTokensSortDirection` for sort_direction failed"
                        .to_string()
                });
            self
        }
        pub fn tag<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::GetHotTokensTag>,
        {
            self.tag = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `GetHotTokensTag` for tag failed".to_string()
                });
            self
        }
        ///Sends a `GET` request to `/v1/ranking/{chain}/hotTokens/{duration}`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<::std::vec::Vec<types::Token>>, Error<()>> {
            let Self {
                client,
                chain,
                duration,
                exclude_keywords,
                filters,
                launchpad_platform,
                range_filters,
                search_keywords,
                sort_by,
                sort_direction,
                tag,
            } = self;
            let chain = chain.map_err(Error::InvalidRequest)?;
            let duration = duration.map_err(Error::InvalidRequest)?;
            let exclude_keywords = exclude_keywords.map_err(Error::InvalidRequest)?;
            let filters = filters.map_err(Error::InvalidRequest)?;
            let launchpad_platform = launchpad_platform.map_err(Error::InvalidRequest)?;
            let range_filters = range_filters.map_err(Error::InvalidRequest)?;
            let search_keywords = search_keywords.map_err(Error::InvalidRequest)?;
            let sort_by = sort_by.map_err(Error::InvalidRequest)?;
            let sort_direction = sort_direction.map_err(Error::InvalidRequest)?;
            let tag = tag.map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v1/ranking/{}/hotTokens/{}", client.baseurl, encode_path(& chain
                .to_string()), encode_path(& duration.to_string()),
            );
            let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
            header_map
                .append(
                    ::reqwest::header::HeaderName::from_static("api-version"),
                    ::reqwest::header::HeaderValue::from_static(
                        super::Client::api_version(),
                    ),
                );
            #[allow(unused_mut)]
            let mut request = client
                .client
                .get(url)
                .header(
                    ::reqwest::header::ACCEPT,
                    ::reqwest::header::HeaderValue::from_static("application/json"),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "excludeKeywords",
                        &exclude_keywords,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new("filters", &filters),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "launchpadPlatform",
                        &launchpad_platform,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "rangeFilters",
                        &range_filters,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "searchKeywords",
                        &search_keywords,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new("sortBy", &sort_by),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "sortDirection",
                        &sort_direction,
                    ),
                )
                .query(&progenitor_middleware_client::QueryParam::new("tag", &tag))
                .headers(header_map)
                .build()?;
            let info = OperationInfo {
                operation_id: "get_hot_tokens",
            };
            client.pre(&mut request, &info).await?;
            let result = client.exec(request, &info).await;
            client.post(&result, &info).await?;
            let response = result?;
            match response.status().as_u16() {
                200u16 => ResponseValue::from_response::<()>(response).await,
                _ => Err(Error::UnexpectedResponse(response)),
            }
        }
    }
    /**Builder for [`Client::get_migrated_tokens`]

[`Client::get_migrated_tokens`]: super::Client::get_migrated_tokens*/
    #[derive(Debug, Clone)]
    pub struct GetMigratedTokens<'a> {
        client: &'a super::Client,
        chain: Result<types::ChainSymbol, String>,
        exclude_keywords: Result<Option<::std::vec::Vec<::std::string::String>>, String>,
        filters: Result<Option<::std::vec::Vec<::std::string::String>>, String>,
        launchpad_platform: Result<
            Option<::std::vec::Vec<::std::string::String>>,
            String,
        >,
        range_filters: Result<Option<::std::vec::Vec<types::FilterCondition>>, String>,
        search_keywords: Result<Option<::std::vec::Vec<::std::string::String>>, String>,
        sort_by: Result<Option<types::GetMigratedTokensSortBy>, String>,
        sort_direction: Result<Option<types::GetMigratedTokensSortDirection>, String>,
        tag: Result<Option<types::GetMigratedTokensTag>, String>,
    }
    impl<'a> GetMigratedTokens<'a> {
        pub fn new(client: &'a super::Client) -> Self {
            Self {
                client: client,
                chain: Err("chain was not initialized".to_string()),
                exclude_keywords: Ok(None),
                filters: Ok(None),
                launchpad_platform: Ok(None),
                range_filters: Ok(None),
                search_keywords: Ok(None),
                sort_by: Ok(None),
                sort_direction: Ok(None),
                tag: Ok(None),
            }
        }
        pub fn chain<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::ChainSymbol>,
        {
            self.chain = value
                .try_into()
                .map_err(|_| "conversion to `ChainSymbol` for chain failed".to_string());
            self
        }
        pub fn exclude_keywords<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::vec::Vec<::std::string::String>>,
        {
            self.exclude_keywords = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: vec :: Vec < :: std :: string :: String >` for exclude_keywords failed"
                        .to_string()
                });
            self
        }
        pub fn filters<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::vec::Vec<::std::string::String>>,
        {
            self.filters = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: vec :: Vec < :: std :: string :: String >` for filters failed"
                        .to_string()
                });
            self
        }
        pub fn launchpad_platform<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::vec::Vec<::std::string::String>>,
        {
            self.launchpad_platform = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: vec :: Vec < :: std :: string :: String >` for launchpad_platform failed"
                        .to_string()
                });
            self
        }
        pub fn range_filters<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::vec::Vec<types::FilterCondition>>,
        {
            self.range_filters = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: vec :: Vec < FilterCondition >` for range_filters failed"
                        .to_string()
                });
            self
        }
        pub fn search_keywords<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::vec::Vec<::std::string::String>>,
        {
            self.search_keywords = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: vec :: Vec < :: std :: string :: String >` for search_keywords failed"
                        .to_string()
                });
            self
        }
        pub fn sort_by<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::GetMigratedTokensSortBy>,
        {
            self.sort_by = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `GetMigratedTokensSortBy` for sort_by failed"
                        .to_string()
                });
            self
        }
        pub fn sort_direction<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::GetMigratedTokensSortDirection>,
        {
            self.sort_direction = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `GetMigratedTokensSortDirection` for sort_direction failed"
                        .to_string()
                });
            self
        }
        pub fn tag<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::GetMigratedTokensTag>,
        {
            self.tag = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `GetMigratedTokensTag` for tag failed".to_string()
                });
            self
        }
        ///Sends a `GET` request to `/v1/ranking/{chain}/migrated`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<::std::vec::Vec<types::Token>>, Error<()>> {
            let Self {
                client,
                chain,
                exclude_keywords,
                filters,
                launchpad_platform,
                range_filters,
                search_keywords,
                sort_by,
                sort_direction,
                tag,
            } = self;
            let chain = chain.map_err(Error::InvalidRequest)?;
            let exclude_keywords = exclude_keywords.map_err(Error::InvalidRequest)?;
            let filters = filters.map_err(Error::InvalidRequest)?;
            let launchpad_platform = launchpad_platform.map_err(Error::InvalidRequest)?;
            let range_filters = range_filters.map_err(Error::InvalidRequest)?;
            let search_keywords = search_keywords.map_err(Error::InvalidRequest)?;
            let sort_by = sort_by.map_err(Error::InvalidRequest)?;
            let sort_direction = sort_direction.map_err(Error::InvalidRequest)?;
            let tag = tag.map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v1/ranking/{}/migrated", client.baseurl, encode_path(& chain
                .to_string()),
            );
            let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
            header_map
                .append(
                    ::reqwest::header::HeaderName::from_static("api-version"),
                    ::reqwest::header::HeaderValue::from_static(
                        super::Client::api_version(),
                    ),
                );
            #[allow(unused_mut)]
            let mut request = client
                .client
                .get(url)
                .header(
                    ::reqwest::header::ACCEPT,
                    ::reqwest::header::HeaderValue::from_static("application/json"),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "excludeKeywords",
                        &exclude_keywords,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new("filters", &filters),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "launchpadPlatform",
                        &launchpad_platform,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "rangeFilters",
                        &range_filters,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "searchKeywords",
                        &search_keywords,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new("sortBy", &sort_by),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "sortDirection",
                        &sort_direction,
                    ),
                )
                .query(&progenitor_middleware_client::QueryParam::new("tag", &tag))
                .headers(header_map)
                .build()?;
            let info = OperationInfo {
                operation_id: "get_migrated_tokens",
            };
            client.pre(&mut request, &info).await?;
            let result = client.exec(request, &info).await;
            client.post(&result, &info).await?;
            let response = result?;
            match response.status().as_u16() {
                200u16 => ResponseValue::from_response::<()>(response).await,
                _ => Err(Error::UnexpectedResponse(response)),
            }
        }
    }
    /**Builder for [`Client::get_new_tokens`]

[`Client::get_new_tokens`]: super::Client::get_new_tokens*/
    #[derive(Debug, Clone)]
    pub struct GetNewTokens<'a> {
        client: &'a super::Client,
        chain: Result<types::ChainSymbol, String>,
        exclude_keywords: Result<Option<::std::vec::Vec<::std::string::String>>, String>,
        filters: Result<Option<::std::vec::Vec<::std::string::String>>, String>,
        launchpad_platform: Result<
            Option<::std::vec::Vec<::std::string::String>>,
            String,
        >,
        range_filters: Result<Option<::std::vec::Vec<types::FilterCondition>>, String>,
        search_keywords: Result<Option<::std::vec::Vec<::std::string::String>>, String>,
        sort_by: Result<Option<types::GetNewTokensSortBy>, String>,
        sort_direction: Result<Option<types::GetNewTokensSortDirection>, String>,
        tag: Result<Option<types::GetNewTokensTag>, String>,
    }
    impl<'a> GetNewTokens<'a> {
        pub fn new(client: &'a super::Client) -> Self {
            Self {
                client: client,
                chain: Err("chain was not initialized".to_string()),
                exclude_keywords: Ok(None),
                filters: Ok(None),
                launchpad_platform: Ok(None),
                range_filters: Ok(None),
                search_keywords: Ok(None),
                sort_by: Ok(None),
                sort_direction: Ok(None),
                tag: Ok(None),
            }
        }
        pub fn chain<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::ChainSymbol>,
        {
            self.chain = value
                .try_into()
                .map_err(|_| "conversion to `ChainSymbol` for chain failed".to_string());
            self
        }
        pub fn exclude_keywords<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::vec::Vec<::std::string::String>>,
        {
            self.exclude_keywords = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: vec :: Vec < :: std :: string :: String >` for exclude_keywords failed"
                        .to_string()
                });
            self
        }
        pub fn filters<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::vec::Vec<::std::string::String>>,
        {
            self.filters = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: vec :: Vec < :: std :: string :: String >` for filters failed"
                        .to_string()
                });
            self
        }
        pub fn launchpad_platform<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::vec::Vec<::std::string::String>>,
        {
            self.launchpad_platform = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: vec :: Vec < :: std :: string :: String >` for launchpad_platform failed"
                        .to_string()
                });
            self
        }
        pub fn range_filters<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::vec::Vec<types::FilterCondition>>,
        {
            self.range_filters = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: vec :: Vec < FilterCondition >` for range_filters failed"
                        .to_string()
                });
            self
        }
        pub fn search_keywords<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::vec::Vec<::std::string::String>>,
        {
            self.search_keywords = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: vec :: Vec < :: std :: string :: String >` for search_keywords failed"
                        .to_string()
                });
            self
        }
        pub fn sort_by<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::GetNewTokensSortBy>,
        {
            self.sort_by = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `GetNewTokensSortBy` for sort_by failed".to_string()
                });
            self
        }
        pub fn sort_direction<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::GetNewTokensSortDirection>,
        {
            self.sort_direction = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `GetNewTokensSortDirection` for sort_direction failed"
                        .to_string()
                });
            self
        }
        pub fn tag<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::GetNewTokensTag>,
        {
            self.tag = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `GetNewTokensTag` for tag failed".to_string()
                });
            self
        }
        ///Sends a `GET` request to `/v1/ranking/{chain}/newTokens`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<::std::vec::Vec<types::Token>>, Error<()>> {
            let Self {
                client,
                chain,
                exclude_keywords,
                filters,
                launchpad_platform,
                range_filters,
                search_keywords,
                sort_by,
                sort_direction,
                tag,
            } = self;
            let chain = chain.map_err(Error::InvalidRequest)?;
            let exclude_keywords = exclude_keywords.map_err(Error::InvalidRequest)?;
            let filters = filters.map_err(Error::InvalidRequest)?;
            let launchpad_platform = launchpad_platform.map_err(Error::InvalidRequest)?;
            let range_filters = range_filters.map_err(Error::InvalidRequest)?;
            let search_keywords = search_keywords.map_err(Error::InvalidRequest)?;
            let sort_by = sort_by.map_err(Error::InvalidRequest)?;
            let sort_direction = sort_direction.map_err(Error::InvalidRequest)?;
            let tag = tag.map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v1/ranking/{}/newTokens", client.baseurl, encode_path(& chain
                .to_string()),
            );
            let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
            header_map
                .append(
                    ::reqwest::header::HeaderName::from_static("api-version"),
                    ::reqwest::header::HeaderValue::from_static(
                        super::Client::api_version(),
                    ),
                );
            #[allow(unused_mut)]
            let mut request = client
                .client
                .get(url)
                .header(
                    ::reqwest::header::ACCEPT,
                    ::reqwest::header::HeaderValue::from_static("application/json"),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "excludeKeywords",
                        &exclude_keywords,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new("filters", &filters),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "launchpadPlatform",
                        &launchpad_platform,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "rangeFilters",
                        &range_filters,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "searchKeywords",
                        &search_keywords,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new("sortBy", &sort_by),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "sortDirection",
                        &sort_direction,
                    ),
                )
                .query(&progenitor_middleware_client::QueryParam::new("tag", &tag))
                .headers(header_map)
                .build()?;
            let info = OperationInfo {
                operation_id: "get_new_tokens",
            };
            client.pre(&mut request, &info).await?;
            let result = client.exec(request, &info).await;
            client.post(&result, &info).await?;
            let response = result?;
            match response.status().as_u16() {
                200u16 => ResponseValue::from_response::<()>(response).await,
                _ => Err(Error::UnexpectedResponse(response)),
            }
        }
    }
    /**Builder for [`Client::get_stocks_tokens`]

[`Client::get_stocks_tokens`]: super::Client::get_stocks_tokens*/
    #[derive(Debug, Clone)]
    pub struct GetStocksTokens<'a> {
        client: &'a super::Client,
        chain: Result<types::ChainSymbol, String>,
        exclude_keywords: Result<Option<::std::vec::Vec<::std::string::String>>, String>,
        filters: Result<Option<::std::vec::Vec<::std::string::String>>, String>,
        launchpad_platform: Result<
            Option<::std::vec::Vec<::std::string::String>>,
            String,
        >,
        range_filters: Result<Option<::std::vec::Vec<types::FilterCondition>>, String>,
        search_keywords: Result<Option<::std::vec::Vec<::std::string::String>>, String>,
        sort_by: Result<Option<types::GetStocksTokensSortBy>, String>,
        sort_direction: Result<Option<types::GetStocksTokensSortDirection>, String>,
        tag: Result<Option<types::GetStocksTokensTag>, String>,
    }
    impl<'a> GetStocksTokens<'a> {
        pub fn new(client: &'a super::Client) -> Self {
            Self {
                client: client,
                chain: Err("chain was not initialized".to_string()),
                exclude_keywords: Ok(None),
                filters: Ok(None),
                launchpad_platform: Ok(None),
                range_filters: Ok(None),
                search_keywords: Ok(None),
                sort_by: Ok(None),
                sort_direction: Ok(None),
                tag: Ok(None),
            }
        }
        pub fn chain<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::ChainSymbol>,
        {
            self.chain = value
                .try_into()
                .map_err(|_| "conversion to `ChainSymbol` for chain failed".to_string());
            self
        }
        pub fn exclude_keywords<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::vec::Vec<::std::string::String>>,
        {
            self.exclude_keywords = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: vec :: Vec < :: std :: string :: String >` for exclude_keywords failed"
                        .to_string()
                });
            self
        }
        pub fn filters<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::vec::Vec<::std::string::String>>,
        {
            self.filters = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: vec :: Vec < :: std :: string :: String >` for filters failed"
                        .to_string()
                });
            self
        }
        pub fn launchpad_platform<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::vec::Vec<::std::string::String>>,
        {
            self.launchpad_platform = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: vec :: Vec < :: std :: string :: String >` for launchpad_platform failed"
                        .to_string()
                });
            self
        }
        pub fn range_filters<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::vec::Vec<types::FilterCondition>>,
        {
            self.range_filters = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: vec :: Vec < FilterCondition >` for range_filters failed"
                        .to_string()
                });
            self
        }
        pub fn search_keywords<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::vec::Vec<::std::string::String>>,
        {
            self.search_keywords = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: vec :: Vec < :: std :: string :: String >` for search_keywords failed"
                        .to_string()
                });
            self
        }
        pub fn sort_by<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::GetStocksTokensSortBy>,
        {
            self.sort_by = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `GetStocksTokensSortBy` for sort_by failed"
                        .to_string()
                });
            self
        }
        pub fn sort_direction<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::GetStocksTokensSortDirection>,
        {
            self.sort_direction = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `GetStocksTokensSortDirection` for sort_direction failed"
                        .to_string()
                });
            self
        }
        pub fn tag<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::GetStocksTokensTag>,
        {
            self.tag = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `GetStocksTokensTag` for tag failed".to_string()
                });
            self
        }
        ///Sends a `GET` request to `/v1/ranking/{chain}/stocks`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<::std::vec::Vec<types::Token>>, Error<()>> {
            let Self {
                client,
                chain,
                exclude_keywords,
                filters,
                launchpad_platform,
                range_filters,
                search_keywords,
                sort_by,
                sort_direction,
                tag,
            } = self;
            let chain = chain.map_err(Error::InvalidRequest)?;
            let exclude_keywords = exclude_keywords.map_err(Error::InvalidRequest)?;
            let filters = filters.map_err(Error::InvalidRequest)?;
            let launchpad_platform = launchpad_platform.map_err(Error::InvalidRequest)?;
            let range_filters = range_filters.map_err(Error::InvalidRequest)?;
            let search_keywords = search_keywords.map_err(Error::InvalidRequest)?;
            let sort_by = sort_by.map_err(Error::InvalidRequest)?;
            let sort_direction = sort_direction.map_err(Error::InvalidRequest)?;
            let tag = tag.map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v1/ranking/{}/stocks", client.baseurl, encode_path(& chain
                .to_string()),
            );
            let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
            header_map
                .append(
                    ::reqwest::header::HeaderName::from_static("api-version"),
                    ::reqwest::header::HeaderValue::from_static(
                        super::Client::api_version(),
                    ),
                );
            #[allow(unused_mut)]
            let mut request = client
                .client
                .get(url)
                .header(
                    ::reqwest::header::ACCEPT,
                    ::reqwest::header::HeaderValue::from_static("application/json"),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "excludeKeywords",
                        &exclude_keywords,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new("filters", &filters),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "launchpadPlatform",
                        &launchpad_platform,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "rangeFilters",
                        &range_filters,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "searchKeywords",
                        &search_keywords,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new("sortBy", &sort_by),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "sortDirection",
                        &sort_direction,
                    ),
                )
                .query(&progenitor_middleware_client::QueryParam::new("tag", &tag))
                .headers(header_map)
                .build()?;
            let info = OperationInfo {
                operation_id: "get_stocks_tokens",
            };
            client.pre(&mut request, &info).await?;
            let result = client.exec(request, &info).await;
            client.post(&result, &info).await?;
            let response = result?;
            match response.status().as_u16() {
                200u16 => ResponseValue::from_response::<()>(response).await,
                _ => Err(Error::UnexpectedResponse(response)),
            }
        }
    }
    /**Builder for [`Client::get_redpackets`]

[`Client::get_redpackets`]: super::Client::get_redpackets*/
    #[derive(Debug, Clone)]
    pub struct GetRedpackets<'a> {
        client: &'a super::Client,
        chain: Result<Option<types::GetRedpacketsChain>, String>,
        creator: Result<Option<::std::string::String>, String>,
        cursor: Result<Option<::std::string::String>, String>,
        direction: Result<Option<::std::string::String>, String>,
        limit: Result<Option<::std::num::NonZeroU64>, String>,
    }
    impl<'a> GetRedpackets<'a> {
        pub fn new(client: &'a super::Client) -> Self {
            Self {
                client: client,
                chain: Ok(None),
                creator: Ok(None),
                cursor: Ok(None),
                direction: Ok(None),
                limit: Ok(None),
            }
        }
        pub fn chain<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::GetRedpacketsChain>,
        {
            self.chain = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `GetRedpacketsChain` for chain failed".to_string()
                });
            self
        }
        pub fn creator<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.creator = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for creator failed"
                        .to_string()
                });
            self
        }
        pub fn cursor<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.cursor = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for cursor failed"
                        .to_string()
                });
            self
        }
        pub fn direction<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.direction = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for direction failed"
                        .to_string()
                });
            self
        }
        pub fn limit<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::num::NonZeroU64>,
        {
            self.limit = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: num :: NonZeroU64` for limit failed"
                        .to_string()
                });
            self
        }
        ///Sends a `GET` request to `/v1/redpacket`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::RedPacketsPage>, Error<()>> {
            let Self { client, chain, creator, cursor, direction, limit } = self;
            let chain = chain.map_err(Error::InvalidRequest)?;
            let creator = creator.map_err(Error::InvalidRequest)?;
            let cursor = cursor.map_err(Error::InvalidRequest)?;
            let direction = direction.map_err(Error::InvalidRequest)?;
            let limit = limit.map_err(Error::InvalidRequest)?;
            let url = format!("{}/v1/redpacket", client.baseurl,);
            let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
            header_map
                .append(
                    ::reqwest::header::HeaderName::from_static("api-version"),
                    ::reqwest::header::HeaderValue::from_static(
                        super::Client::api_version(),
                    ),
                );
            #[allow(unused_mut)]
            let mut request = client
                .client
                .get(url)
                .header(
                    ::reqwest::header::ACCEPT,
                    ::reqwest::header::HeaderValue::from_static("application/json"),
                )
                .query(&progenitor_middleware_client::QueryParam::new("chain", &chain))
                .query(
                    &progenitor_middleware_client::QueryParam::new("creator", &creator),
                )
                .query(&progenitor_middleware_client::QueryParam::new("cursor", &cursor))
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "direction",
                        &direction,
                    ),
                )
                .query(&progenitor_middleware_client::QueryParam::new("limit", &limit))
                .headers(header_map)
                .build()?;
            let info = OperationInfo {
                operation_id: "get_redpackets",
            };
            client.pre(&mut request, &info).await?;
            let result = client.exec(request, &info).await;
            client.post(&result, &info).await?;
            let response = result?;
            match response.status().as_u16() {
                200u16 => ResponseValue::from_response::<()>(response).await,
                _ => Err(Error::UnexpectedResponse(response)),
            }
        }
    }
    /**Builder for [`Client::get_claims_by_address`]

[`Client::get_claims_by_address`]: super::Client::get_claims_by_address*/
    #[derive(Debug, Clone)]
    pub struct GetClaimsByAddress<'a> {
        client: &'a super::Client,
        address: Result<::std::string::String, String>,
        cursor: Result<Option<::std::string::String>, String>,
        direction: Result<Option<::std::string::String>, String>,
        limit: Result<Option<::std::num::NonZeroU64>, String>,
    }
    impl<'a> GetClaimsByAddress<'a> {
        pub fn new(client: &'a super::Client) -> Self {
            Self {
                client: client,
                address: Err("address was not initialized".to_string()),
                cursor: Ok(None),
                direction: Ok(None),
                limit: Ok(None),
            }
        }
        pub fn address<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.address = value
                .try_into()
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for address failed"
                        .to_string()
                });
            self
        }
        pub fn cursor<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.cursor = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for cursor failed"
                        .to_string()
                });
            self
        }
        pub fn direction<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.direction = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for direction failed"
                        .to_string()
                });
            self
        }
        pub fn limit<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::num::NonZeroU64>,
        {
            self.limit = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: num :: NonZeroU64` for limit failed"
                        .to_string()
                });
            self
        }
        ///Sends a `GET` request to `/v1/redpacket/wallet/{address}/claims`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::RedPacketClaimsPage>, Error<()>> {
            let Self { client, address, cursor, direction, limit } = self;
            let address = address.map_err(Error::InvalidRequest)?;
            let cursor = cursor.map_err(Error::InvalidRequest)?;
            let direction = direction.map_err(Error::InvalidRequest)?;
            let limit = limit.map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v1/redpacket/wallet/{}/claims", client.baseurl, encode_path(& address
                .to_string()),
            );
            let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
            header_map
                .append(
                    ::reqwest::header::HeaderName::from_static("api-version"),
                    ::reqwest::header::HeaderValue::from_static(
                        super::Client::api_version(),
                    ),
                );
            #[allow(unused_mut)]
            let mut request = client
                .client
                .get(url)
                .header(
                    ::reqwest::header::ACCEPT,
                    ::reqwest::header::HeaderValue::from_static("application/json"),
                )
                .query(&progenitor_middleware_client::QueryParam::new("cursor", &cursor))
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "direction",
                        &direction,
                    ),
                )
                .query(&progenitor_middleware_client::QueryParam::new("limit", &limit))
                .headers(header_map)
                .build()?;
            let info = OperationInfo {
                operation_id: "get_claims_by_address",
            };
            client.pre(&mut request, &info).await?;
            let result = client.exec(request, &info).await;
            client.post(&result, &info).await?;
            let response = result?;
            match response.status().as_u16() {
                200u16 => ResponseValue::from_response::<()>(response).await,
                _ => Err(Error::UnexpectedResponse(response)),
            }
        }
    }
    /**Builder for [`Client::get_redpackets_by_address`]

[`Client::get_redpackets_by_address`]: super::Client::get_redpackets_by_address*/
    #[derive(Debug, Clone)]
    pub struct GetRedpacketsByAddress<'a> {
        client: &'a super::Client,
        address: Result<::std::string::String, String>,
        cursor: Result<Option<::std::string::String>, String>,
        direction: Result<Option<::std::string::String>, String>,
        limit: Result<Option<::std::num::NonZeroU64>, String>,
    }
    impl<'a> GetRedpacketsByAddress<'a> {
        pub fn new(client: &'a super::Client) -> Self {
            Self {
                client: client,
                address: Err("address was not initialized".to_string()),
                cursor: Ok(None),
                direction: Ok(None),
                limit: Ok(None),
            }
        }
        pub fn address<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.address = value
                .try_into()
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for address failed"
                        .to_string()
                });
            self
        }
        pub fn cursor<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.cursor = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for cursor failed"
                        .to_string()
                });
            self
        }
        pub fn direction<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.direction = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for direction failed"
                        .to_string()
                });
            self
        }
        pub fn limit<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::num::NonZeroU64>,
        {
            self.limit = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: num :: NonZeroU64` for limit failed"
                        .to_string()
                });
            self
        }
        ///Sends a `GET` request to `/v1/redpacket/wallet/{address}/redpackets`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::RedPacketsPage>, Error<()>> {
            let Self { client, address, cursor, direction, limit } = self;
            let address = address.map_err(Error::InvalidRequest)?;
            let cursor = cursor.map_err(Error::InvalidRequest)?;
            let direction = direction.map_err(Error::InvalidRequest)?;
            let limit = limit.map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v1/redpacket/wallet/{}/redpackets", client.baseurl, encode_path(&
                address.to_string()),
            );
            let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
            header_map
                .append(
                    ::reqwest::header::HeaderName::from_static("api-version"),
                    ::reqwest::header::HeaderValue::from_static(
                        super::Client::api_version(),
                    ),
                );
            #[allow(unused_mut)]
            let mut request = client
                .client
                .get(url)
                .header(
                    ::reqwest::header::ACCEPT,
                    ::reqwest::header::HeaderValue::from_static("application/json"),
                )
                .query(&progenitor_middleware_client::QueryParam::new("cursor", &cursor))
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "direction",
                        &direction,
                    ),
                )
                .query(&progenitor_middleware_client::QueryParam::new("limit", &limit))
                .headers(header_map)
                .build()?;
            let info = OperationInfo {
                operation_id: "get_redpackets_by_address",
            };
            client.pre(&mut request, &info).await?;
            let result = client.exec(request, &info).await;
            client.post(&result, &info).await?;
            let response = result?;
            match response.status().as_u16() {
                200u16 => ResponseValue::from_response::<()>(response).await,
                _ => Err(Error::UnexpectedResponse(response)),
            }
        }
    }
    /**Builder for [`Client::claim_redpacket`]

[`Client::claim_redpacket`]: super::Client::claim_redpacket*/
    #[derive(Debug, Clone)]
    pub struct ClaimRedpacket<'a> {
        client: &'a super::Client,
        chain: Result<types::ChainSymbol, String>,
        body: Result<types::builder::ClaimRedPacketInput, String>,
    }
    impl<'a> ClaimRedpacket<'a> {
        pub fn new(client: &'a super::Client) -> Self {
            Self {
                client: client,
                chain: Err("chain was not initialized".to_string()),
                body: Ok(::std::default::Default::default()),
            }
        }
        pub fn chain<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::ChainSymbol>,
        {
            self.chain = value
                .try_into()
                .map_err(|_| "conversion to `ChainSymbol` for chain failed".to_string());
            self
        }
        pub fn body<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::ClaimRedPacketInput>,
            <V as std::convert::TryInto<
                types::ClaimRedPacketInput,
            >>::Error: std::fmt::Display,
        {
            self.body = value
                .try_into()
                .map(From::from)
                .map_err(|s| {
                    format!("conversion to `ClaimRedPacketInput` for body failed: {}", s)
                });
            self
        }
        pub fn body_map<F>(mut self, f: F) -> Self
        where
            F: std::ops::FnOnce(
                types::builder::ClaimRedPacketInput,
            ) -> types::builder::ClaimRedPacketInput,
        {
            self.body = self.body.map(f);
            self
        }
        ///Sends a `POST` request to `/v1/redpacket/{chain}/claim`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::RedPacketReply>, Error<()>> {
            let Self { client, chain, body } = self;
            let chain = chain.map_err(Error::InvalidRequest)?;
            let body = body
                .and_then(|v| {
                    types::ClaimRedPacketInput::try_from(v).map_err(|e| e.to_string())
                })
                .map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v1/redpacket/{}/claim", client.baseurl, encode_path(& chain
                .to_string()),
            );
            let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
            header_map
                .append(
                    ::reqwest::header::HeaderName::from_static("api-version"),
                    ::reqwest::header::HeaderValue::from_static(
                        super::Client::api_version(),
                    ),
                );
            #[allow(unused_mut)]
            let mut request = client
                .client
                .post(url)
                .header(
                    ::reqwest::header::ACCEPT,
                    ::reqwest::header::HeaderValue::from_static("application/json"),
                )
                .json(&body)
                .headers(header_map)
                .build()?;
            let info = OperationInfo {
                operation_id: "claim_redpacket",
            };
            client.pre(&mut request, &info).await?;
            let result = client.exec(request, &info).await;
            client.post(&result, &info).await?;
            let response = result?;
            match response.status().as_u16() {
                200u16 => ResponseValue::from_response::<()>(response).await,
                _ => Err(Error::UnexpectedResponse(response)),
            }
        }
    }
    /**Builder for [`Client::create_redpacket`]

[`Client::create_redpacket`]: super::Client::create_redpacket*/
    #[derive(Debug, Clone)]
    pub struct CreateRedpacket<'a> {
        client: &'a super::Client,
        chain: Result<types::ChainSymbol, String>,
        body: Result<types::builder::CreateRedPacketInput, String>,
    }
    impl<'a> CreateRedpacket<'a> {
        pub fn new(client: &'a super::Client) -> Self {
            Self {
                client: client,
                chain: Err("chain was not initialized".to_string()),
                body: Ok(::std::default::Default::default()),
            }
        }
        pub fn chain<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::ChainSymbol>,
        {
            self.chain = value
                .try_into()
                .map_err(|_| "conversion to `ChainSymbol` for chain failed".to_string());
            self
        }
        pub fn body<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::CreateRedPacketInput>,
            <V as std::convert::TryInto<
                types::CreateRedPacketInput,
            >>::Error: std::fmt::Display,
        {
            self.body = value
                .try_into()
                .map(From::from)
                .map_err(|s| {
                    format!(
                        "conversion to `CreateRedPacketInput` for body failed: {}", s
                    )
                });
            self
        }
        pub fn body_map<F>(mut self, f: F) -> Self
        where
            F: std::ops::FnOnce(
                types::builder::CreateRedPacketInput,
            ) -> types::builder::CreateRedPacketInput,
        {
            self.body = self.body.map(f);
            self
        }
        ///Sends a `POST` request to `/v1/redpacket/{chain}/create`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::CreateRedPacketReply>, Error<()>> {
            let Self { client, chain, body } = self;
            let chain = chain.map_err(Error::InvalidRequest)?;
            let body = body
                .and_then(|v| {
                    types::CreateRedPacketInput::try_from(v).map_err(|e| e.to_string())
                })
                .map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v1/redpacket/{}/create", client.baseurl, encode_path(& chain
                .to_string()),
            );
            let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
            header_map
                .append(
                    ::reqwest::header::HeaderName::from_static("api-version"),
                    ::reqwest::header::HeaderValue::from_static(
                        super::Client::api_version(),
                    ),
                );
            #[allow(unused_mut)]
            let mut request = client
                .client
                .post(url)
                .header(
                    ::reqwest::header::ACCEPT,
                    ::reqwest::header::HeaderValue::from_static("application/json"),
                )
                .json(&body)
                .headers(header_map)
                .build()?;
            let info = OperationInfo {
                operation_id: "create_redpacket",
            };
            client.pre(&mut request, &info).await?;
            let result = client.exec(request, &info).await;
            client.post(&result, &info).await?;
            let response = result?;
            match response.status().as_u16() {
                200u16 => ResponseValue::from_response::<()>(response).await,
                _ => Err(Error::UnexpectedResponse(response)),
            }
        }
    }
    /**Builder for [`Client::redpacket_send`]

[`Client::redpacket_send`]: super::Client::redpacket_send*/
    #[derive(Debug, Clone)]
    pub struct RedpacketSend<'a> {
        client: &'a super::Client,
        chain: Result<types::ChainSymbol, String>,
        body: Result<types::builder::RedPacketSendTxInput, String>,
    }
    impl<'a> RedpacketSend<'a> {
        pub fn new(client: &'a super::Client) -> Self {
            Self {
                client: client,
                chain: Err("chain was not initialized".to_string()),
                body: Ok(::std::default::Default::default()),
            }
        }
        pub fn chain<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::ChainSymbol>,
        {
            self.chain = value
                .try_into()
                .map_err(|_| "conversion to `ChainSymbol` for chain failed".to_string());
            self
        }
        pub fn body<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::RedPacketSendTxInput>,
            <V as std::convert::TryInto<
                types::RedPacketSendTxInput,
            >>::Error: std::fmt::Display,
        {
            self.body = value
                .try_into()
                .map(From::from)
                .map_err(|s| {
                    format!(
                        "conversion to `RedPacketSendTxInput` for body failed: {}", s
                    )
                });
            self
        }
        pub fn body_map<F>(mut self, f: F) -> Self
        where
            F: std::ops::FnOnce(
                types::builder::RedPacketSendTxInput,
            ) -> types::builder::RedPacketSendTxInput,
        {
            self.body = self.body.map(f);
            self
        }
        ///Sends a `POST` request to `/v1/redpacket/{chain}/send`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::RedPacketSendTxResponse>, Error<()>> {
            let Self { client, chain, body } = self;
            let chain = chain.map_err(Error::InvalidRequest)?;
            let body = body
                .and_then(|v| {
                    types::RedPacketSendTxInput::try_from(v).map_err(|e| e.to_string())
                })
                .map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v1/redpacket/{}/send", client.baseurl, encode_path(& chain
                .to_string()),
            );
            let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
            header_map
                .append(
                    ::reqwest::header::HeaderName::from_static("api-version"),
                    ::reqwest::header::HeaderValue::from_static(
                        super::Client::api_version(),
                    ),
                );
            #[allow(unused_mut)]
            let mut request = client
                .client
                .post(url)
                .header(
                    ::reqwest::header::ACCEPT,
                    ::reqwest::header::HeaderValue::from_static("application/json"),
                )
                .json(&body)
                .headers(header_map)
                .build()?;
            let info = OperationInfo {
                operation_id: "redpacket_send",
            };
            client.pre(&mut request, &info).await?;
            let result = client.exec(request, &info).await;
            client.post(&result, &info).await?;
            let response = result?;
            match response.status().as_u16() {
                200u16 => ResponseValue::from_response::<()>(response).await,
                _ => Err(Error::UnexpectedResponse(response)),
            }
        }
    }
    /**Builder for [`Client::get_redpacket`]

[`Client::get_redpacket`]: super::Client::get_redpacket*/
    #[derive(Debug, Clone)]
    pub struct GetRedpacket<'a> {
        client: &'a super::Client,
        id: Result<::std::string::String, String>,
    }
    impl<'a> GetRedpacket<'a> {
        pub fn new(client: &'a super::Client) -> Self {
            Self {
                client: client,
                id: Err("id was not initialized".to_string()),
            }
        }
        pub fn id<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.id = value
                .try_into()
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for id failed"
                        .to_string()
                });
            self
        }
        ///Sends a `GET` request to `/v1/redpacket/{id}`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::RedPacketDto>, Error<()>> {
            let Self { client, id } = self;
            let id = id.map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v1/redpacket/{}", client.baseurl, encode_path(& id.to_string()),
            );
            let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
            header_map
                .append(
                    ::reqwest::header::HeaderName::from_static("api-version"),
                    ::reqwest::header::HeaderValue::from_static(
                        super::Client::api_version(),
                    ),
                );
            #[allow(unused_mut)]
            let mut request = client
                .client
                .get(url)
                .header(
                    ::reqwest::header::ACCEPT,
                    ::reqwest::header::HeaderValue::from_static("application/json"),
                )
                .headers(header_map)
                .build()?;
            let info = OperationInfo {
                operation_id: "get_redpacket",
            };
            client.pre(&mut request, &info).await?;
            let result = client.exec(request, &info).await;
            client.post(&result, &info).await?;
            let response = result?;
            match response.status().as_u16() {
                200u16 => ResponseValue::from_response::<()>(response).await,
                _ => Err(Error::UnexpectedResponse(response)),
            }
        }
    }
    /**Builder for [`Client::get_claims`]

[`Client::get_claims`]: super::Client::get_claims*/
    #[derive(Debug, Clone)]
    pub struct GetClaims<'a> {
        client: &'a super::Client,
        id: Result<::std::string::String, String>,
        cursor: Result<Option<::std::string::String>, String>,
        direction: Result<Option<::std::string::String>, String>,
        limit: Result<Option<::std::num::NonZeroU64>, String>,
    }
    impl<'a> GetClaims<'a> {
        pub fn new(client: &'a super::Client) -> Self {
            Self {
                client: client,
                id: Err("id was not initialized".to_string()),
                cursor: Ok(None),
                direction: Ok(None),
                limit: Ok(None),
            }
        }
        pub fn id<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.id = value
                .try_into()
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for id failed"
                        .to_string()
                });
            self
        }
        pub fn cursor<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.cursor = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for cursor failed"
                        .to_string()
                });
            self
        }
        pub fn direction<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.direction = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for direction failed"
                        .to_string()
                });
            self
        }
        pub fn limit<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::num::NonZeroU64>,
        {
            self.limit = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: num :: NonZeroU64` for limit failed"
                        .to_string()
                });
            self
        }
        ///Sends a `GET` request to `/v1/redpacket/{id}/claims`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::RedPacketClaimsPage>, Error<()>> {
            let Self { client, id, cursor, direction, limit } = self;
            let id = id.map_err(Error::InvalidRequest)?;
            let cursor = cursor.map_err(Error::InvalidRequest)?;
            let direction = direction.map_err(Error::InvalidRequest)?;
            let limit = limit.map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v1/redpacket/{}/claims", client.baseurl, encode_path(& id
                .to_string()),
            );
            let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
            header_map
                .append(
                    ::reqwest::header::HeaderName::from_static("api-version"),
                    ::reqwest::header::HeaderValue::from_static(
                        super::Client::api_version(),
                    ),
                );
            #[allow(unused_mut)]
            let mut request = client
                .client
                .get(url)
                .header(
                    ::reqwest::header::ACCEPT,
                    ::reqwest::header::HeaderValue::from_static("application/json"),
                )
                .query(&progenitor_middleware_client::QueryParam::new("cursor", &cursor))
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "direction",
                        &direction,
                    ),
                )
                .query(&progenitor_middleware_client::QueryParam::new("limit", &limit))
                .headers(header_map)
                .build()?;
            let info = OperationInfo {
                operation_id: "get_claims",
            };
            client.pre(&mut request, &info).await?;
            let result = client.exec(request, &info).await;
            client.post(&result, &info).await?;
            let response = result?;
            match response.status().as_u16() {
                200u16 => ResponseValue::from_response::<()>(response).await,
                _ => Err(Error::UnexpectedResponse(response)),
            }
        }
    }
    /**Builder for [`Client::moonshot_create_token`]

[`Client::moonshot_create_token`]: super::Client::moonshot_create_token*/
    #[derive(Debug, Clone)]
    pub struct MoonshotCreateToken<'a> {
        client: &'a super::Client,
        body: Result<types::builder::MoonshotCreateTokenInput, String>,
    }
    impl<'a> MoonshotCreateToken<'a> {
        pub fn new(client: &'a super::Client) -> Self {
            Self {
                client: client,
                body: Ok(::std::default::Default::default()),
            }
        }
        pub fn body<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::MoonshotCreateTokenInput>,
            <V as std::convert::TryInto<
                types::MoonshotCreateTokenInput,
            >>::Error: std::fmt::Display,
        {
            self.body = value
                .try_into()
                .map(From::from)
                .map_err(|s| {
                    format!(
                        "conversion to `MoonshotCreateTokenInput` for body failed: {}", s
                    )
                });
            self
        }
        pub fn body_map<F>(mut self, f: F) -> Self
        where
            F: std::ops::FnOnce(
                types::builder::MoonshotCreateTokenInput,
            ) -> types::builder::MoonshotCreateTokenInput,
        {
            self.body = self.body.map(f);
            self
        }
        ///Sends a `POST` request to `/v1/sol/moonshot/create`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::MoonshotCreateTokenReply>, Error<()>> {
            let Self { client, body } = self;
            let body = body
                .and_then(|v| {
                    types::MoonshotCreateTokenInput::try_from(v)
                        .map_err(|e| e.to_string())
                })
                .map_err(Error::InvalidRequest)?;
            let url = format!("{}/v1/sol/moonshot/create", client.baseurl,);
            let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
            header_map
                .append(
                    ::reqwest::header::HeaderName::from_static("api-version"),
                    ::reqwest::header::HeaderValue::from_static(
                        super::Client::api_version(),
                    ),
                );
            #[allow(unused_mut)]
            let mut request = client
                .client
                .post(url)
                .header(
                    ::reqwest::header::ACCEPT,
                    ::reqwest::header::HeaderValue::from_static("application/json"),
                )
                .json(&body)
                .headers(header_map)
                .build()?;
            let info = OperationInfo {
                operation_id: "moonshot_create_token",
            };
            client.pre(&mut request, &info).await?;
            let result = client.exec(request, &info).await;
            client.post(&result, &info).await?;
            let response = result?;
            match response.status().as_u16() {
                200u16 => ResponseValue::from_response::<()>(response).await,
                _ => Err(Error::UnexpectedResponse(response)),
            }
        }
    }
    /**Builder for [`Client::moonshot_submit_create_token`]

[`Client::moonshot_submit_create_token`]: super::Client::moonshot_submit_create_token*/
    #[derive(Debug, Clone)]
    pub struct MoonshotSubmitCreateToken<'a> {
        client: &'a super::Client,
        body: Result<types::builder::MoonshotSubmitCreateTokenInput, String>,
    }
    impl<'a> MoonshotSubmitCreateToken<'a> {
        pub fn new(client: &'a super::Client) -> Self {
            Self {
                client: client,
                body: Ok(::std::default::Default::default()),
            }
        }
        pub fn body<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::MoonshotSubmitCreateTokenInput>,
            <V as std::convert::TryInto<
                types::MoonshotSubmitCreateTokenInput,
            >>::Error: std::fmt::Display,
        {
            self.body = value
                .try_into()
                .map(From::from)
                .map_err(|s| {
                    format!(
                        "conversion to `MoonshotSubmitCreateTokenInput` for body failed: {}",
                        s
                    )
                });
            self
        }
        pub fn body_map<F>(mut self, f: F) -> Self
        where
            F: std::ops::FnOnce(
                types::builder::MoonshotSubmitCreateTokenInput,
            ) -> types::builder::MoonshotSubmitCreateTokenInput,
        {
            self.body = self.body.map(f);
            self
        }
        ///Sends a `POST` request to `/v1/sol/moonshot/submitCreateToken`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::MoonshotSubmitCreateTokenResponse>, Error<()>> {
            let Self { client, body } = self;
            let body = body
                .and_then(|v| {
                    types::MoonshotSubmitCreateTokenInput::try_from(v)
                        .map_err(|e| e.to_string())
                })
                .map_err(Error::InvalidRequest)?;
            let url = format!("{}/v1/sol/moonshot/submitCreateToken", client.baseurl,);
            let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
            header_map
                .append(
                    ::reqwest::header::HeaderName::from_static("api-version"),
                    ::reqwest::header::HeaderValue::from_static(
                        super::Client::api_version(),
                    ),
                );
            #[allow(unused_mut)]
            let mut request = client
                .client
                .post(url)
                .header(
                    ::reqwest::header::ACCEPT,
                    ::reqwest::header::HeaderValue::from_static("application/json"),
                )
                .json(&body)
                .headers(header_map)
                .build()?;
            let info = OperationInfo {
                operation_id: "moonshot_submit_create_token",
            };
            client.pre(&mut request, &info).await?;
            let result = client.exec(request, &info).await;
            client.post(&result, &info).await?;
            let response = result?;
            match response.status().as_u16() {
                200u16 => ResponseValue::from_response::<()>(response).await,
                _ => Err(Error::UnexpectedResponse(response)),
            }
        }
    }
    /**Builder for [`Client::pumpfun_create_token`]

[`Client::pumpfun_create_token`]: super::Client::pumpfun_create_token*/
    #[derive(Debug, Clone)]
    pub struct PumpfunCreateToken<'a> {
        client: &'a super::Client,
        body: Result<types::builder::PumpCreateTokenInput, String>,
    }
    impl<'a> PumpfunCreateToken<'a> {
        pub fn new(client: &'a super::Client) -> Self {
            Self {
                client: client,
                body: Ok(::std::default::Default::default()),
            }
        }
        pub fn body<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::PumpCreateTokenInput>,
            <V as std::convert::TryInto<
                types::PumpCreateTokenInput,
            >>::Error: std::fmt::Display,
        {
            self.body = value
                .try_into()
                .map(From::from)
                .map_err(|s| {
                    format!(
                        "conversion to `PumpCreateTokenInput` for body failed: {}", s
                    )
                });
            self
        }
        pub fn body_map<F>(mut self, f: F) -> Self
        where
            F: std::ops::FnOnce(
                types::builder::PumpCreateTokenInput,
            ) -> types::builder::PumpCreateTokenInput,
        {
            self.body = self.body.map(f);
            self
        }
        ///Sends a `POST` request to `/v1/sol/pumpfun/create`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::PumpCreateTokenReply>, Error<()>> {
            let Self { client, body } = self;
            let body = body
                .and_then(|v| {
                    types::PumpCreateTokenInput::try_from(v).map_err(|e| e.to_string())
                })
                .map_err(Error::InvalidRequest)?;
            let url = format!("{}/v1/sol/pumpfun/create", client.baseurl,);
            let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
            header_map
                .append(
                    ::reqwest::header::HeaderName::from_static("api-version"),
                    ::reqwest::header::HeaderValue::from_static(
                        super::Client::api_version(),
                    ),
                );
            #[allow(unused_mut)]
            let mut request = client
                .client
                .post(url)
                .header(
                    ::reqwest::header::ACCEPT,
                    ::reqwest::header::HeaderValue::from_static("application/json"),
                )
                .json(&body)
                .headers(header_map)
                .build()?;
            let info = OperationInfo {
                operation_id: "pumpfun_create_token",
            };
            client.pre(&mut request, &info).await?;
            let result = client.exec(request, &info).await;
            client.post(&result, &info).await?;
            let response = result?;
            match response.status().as_u16() {
                200u16 => ResponseValue::from_response::<()>(response).await,
                _ => Err(Error::UnexpectedResponse(response)),
            }
        }
    }
    /**Builder for [`Client::search`]

[`Client::search`]: super::Client::search*/
    #[derive(Debug, Clone)]
    pub struct Search<'a> {
        client: &'a super::Client,
        chains: Result<Option<::std::vec::Vec<::std::string::String>>, String>,
        cursor: Result<Option<::std::string::String>, String>,
        direction: Result<Option<types::SearchDirection>, String>,
        limit: Result<Option<::std::num::NonZeroU64>, String>,
        protocols: Result<Option<::std::vec::Vec<::std::string::String>>, String>,
        q: Result<Option<types::SearchQ>, String>,
        sort: Result<Option<types::SearchSort>, String>,
        sort_by: Result<Option<types::SearchSortBy>, String>,
    }
    impl<'a> Search<'a> {
        pub fn new(client: &'a super::Client) -> Self {
            Self {
                client: client,
                chains: Ok(None),
                cursor: Ok(None),
                direction: Ok(None),
                limit: Ok(None),
                protocols: Ok(None),
                q: Ok(None),
                sort: Ok(None),
                sort_by: Ok(None),
            }
        }
        pub fn chains<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::vec::Vec<::std::string::String>>,
        {
            self.chains = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: vec :: Vec < :: std :: string :: String >` for chains failed"
                        .to_string()
                });
            self
        }
        pub fn cursor<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.cursor = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for cursor failed"
                        .to_string()
                });
            self
        }
        pub fn direction<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::SearchDirection>,
        {
            self.direction = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `SearchDirection` for direction failed".to_string()
                });
            self
        }
        pub fn limit<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::num::NonZeroU64>,
        {
            self.limit = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: num :: NonZeroU64` for limit failed"
                        .to_string()
                });
            self
        }
        pub fn protocols<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::vec::Vec<::std::string::String>>,
        {
            self.protocols = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: vec :: Vec < :: std :: string :: String >` for protocols failed"
                        .to_string()
                });
            self
        }
        pub fn q<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::SearchQ>,
        {
            self.q = value
                .try_into()
                .map(Some)
                .map_err(|_| "conversion to `SearchQ` for q failed".to_string());
            self
        }
        pub fn sort<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::SearchSort>,
        {
            self.sort = value
                .try_into()
                .map(Some)
                .map_err(|_| "conversion to `SearchSort` for sort failed".to_string());
            self
        }
        pub fn sort_by<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::SearchSortBy>,
        {
            self.sort_by = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `SearchSortBy` for sort_by failed".to_string()
                });
            self
        }
        ///Sends a `GET` request to `/v1/token/search`
        pub async fn send(self) -> Result<ResponseValue<types::TokenPage>, Error<()>> {
            let Self {
                client,
                chains,
                cursor,
                direction,
                limit,
                protocols,
                q,
                sort,
                sort_by,
            } = self;
            let chains = chains.map_err(Error::InvalidRequest)?;
            let cursor = cursor.map_err(Error::InvalidRequest)?;
            let direction = direction.map_err(Error::InvalidRequest)?;
            let limit = limit.map_err(Error::InvalidRequest)?;
            let protocols = protocols.map_err(Error::InvalidRequest)?;
            let q = q.map_err(Error::InvalidRequest)?;
            let sort = sort.map_err(Error::InvalidRequest)?;
            let sort_by = sort_by.map_err(Error::InvalidRequest)?;
            let url = format!("{}/v1/token/search", client.baseurl,);
            let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
            header_map
                .append(
                    ::reqwest::header::HeaderName::from_static("api-version"),
                    ::reqwest::header::HeaderValue::from_static(
                        super::Client::api_version(),
                    ),
                );
            #[allow(unused_mut)]
            let mut request = client
                .client
                .get(url)
                .header(
                    ::reqwest::header::ACCEPT,
                    ::reqwest::header::HeaderValue::from_static("application/json"),
                )
                .query(&progenitor_middleware_client::QueryParam::new("chains", &chains))
                .query(&progenitor_middleware_client::QueryParam::new("cursor", &cursor))
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "direction",
                        &direction,
                    ),
                )
                .query(&progenitor_middleware_client::QueryParam::new("limit", &limit))
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "protocols",
                        &protocols,
                    ),
                )
                .query(&progenitor_middleware_client::QueryParam::new("q", &q))
                .query(&progenitor_middleware_client::QueryParam::new("sort", &sort))
                .query(
                    &progenitor_middleware_client::QueryParam::new("sortBy", &sort_by),
                )
                .headers(header_map)
                .build()?;
            let info = OperationInfo {
                operation_id: "search",
            };
            client.pre(&mut request, &info).await?;
            let result = client.exec(request, &info).await;
            client.post(&result, &info).await?;
            let response = result?;
            match response.status().as_u16() {
                200u16 => ResponseValue::from_response::<()>(response).await,
                _ => Err(Error::UnexpectedResponse(response)),
            }
        }
    }
    /**Builder for [`Client::get_dev_tokens`]

[`Client::get_dev_tokens`]: super::Client::get_dev_tokens*/
    #[derive(Debug, Clone)]
    pub struct GetDevTokens<'a> {
        client: &'a super::Client,
        chain: Result<types::ChainSymbol, String>,
        dev_address: Result<::std::string::String, String>,
    }
    impl<'a> GetDevTokens<'a> {
        pub fn new(client: &'a super::Client) -> Self {
            Self {
                client: client,
                chain: Err("chain was not initialized".to_string()),
                dev_address: Err("dev_address was not initialized".to_string()),
            }
        }
        pub fn chain<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::ChainSymbol>,
        {
            self.chain = value
                .try_into()
                .map_err(|_| "conversion to `ChainSymbol` for chain failed".to_string());
            self
        }
        pub fn dev_address<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.dev_address = value
                .try_into()
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for dev_address failed"
                        .to_string()
                });
            self
        }
        ///Sends a `GET` request to `/v1/token/{chain}/dev/{devAddress}/tokens`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<::std::vec::Vec<types::DevTokenDto>>, Error<()>> {
            let Self { client, chain, dev_address } = self;
            let chain = chain.map_err(Error::InvalidRequest)?;
            let dev_address = dev_address.map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v1/token/{}/dev/{}/tokens", client.baseurl, encode_path(& chain
                .to_string()), encode_path(& dev_address.to_string()),
            );
            let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
            header_map
                .append(
                    ::reqwest::header::HeaderName::from_static("api-version"),
                    ::reqwest::header::HeaderValue::from_static(
                        super::Client::api_version(),
                    ),
                );
            #[allow(unused_mut)]
            let mut request = client
                .client
                .get(url)
                .header(
                    ::reqwest::header::ACCEPT,
                    ::reqwest::header::HeaderValue::from_static("application/json"),
                )
                .headers(header_map)
                .build()?;
            let info = OperationInfo {
                operation_id: "get_dev_tokens",
            };
            client.pre(&mut request, &info).await?;
            let result = client.exec(request, &info).await;
            client.post(&result, &info).await?;
            let response = result?;
            match response.status().as_u16() {
                200u16 => ResponseValue::from_response::<()>(response).await,
                _ => Err(Error::UnexpectedResponse(response)),
            }
        }
    }
    /**Builder for [`Client::list_token`]

[`Client::list_token`]: super::Client::list_token*/
    #[derive(Debug, Clone)]
    pub struct ListToken<'a> {
        client: &'a super::Client,
        chain: Result<types::ChainSymbol, String>,
        cursor: Result<Option<::std::string::String>, String>,
        direction: Result<Option<types::ListTokenDirection>, String>,
        limit: Result<Option<::std::num::NonZeroU64>, String>,
        max_h1_buy_volume_in_usd: Result<Option<::std::string::String>, String>,
        max_h1_buyers: Result<Option<::std::string::String>, String>,
        max_h1_buys: Result<Option<::std::string::String>, String>,
        max_h1_price_change_ratio: Result<Option<::std::string::String>, String>,
        max_h1_sell_volume_in_usd: Result<Option<::std::string::String>, String>,
        max_h1_sellers: Result<Option<::std::string::String>, String>,
        max_h1_sells: Result<Option<::std::string::String>, String>,
        max_h1_trades: Result<Option<::std::string::String>, String>,
        max_h1_volume_in_usd: Result<Option<::std::string::String>, String>,
        max_h24_buy_volume_in_usd: Result<Option<::std::string::String>, String>,
        max_h24_buyers: Result<Option<::std::string::String>, String>,
        max_h24_buys: Result<Option<::std::string::String>, String>,
        max_h24_price_change_ratio: Result<Option<::std::string::String>, String>,
        max_h24_sell_volume_in_usd: Result<Option<::std::string::String>, String>,
        max_h24_sellers: Result<Option<::std::string::String>, String>,
        max_h24_sells: Result<Option<::std::string::String>, String>,
        max_h24_trades: Result<Option<::std::string::String>, String>,
        max_h24_volume_in_usd: Result<Option<::std::string::String>, String>,
        max_h4_buy_volume_in_usd: Result<Option<::std::string::String>, String>,
        max_h4_buyers: Result<Option<::std::string::String>, String>,
        max_h4_buys: Result<Option<::std::string::String>, String>,
        max_h4_price_change_ratio: Result<Option<::std::string::String>, String>,
        max_h4_sell_volume_in_usd: Result<Option<::std::string::String>, String>,
        max_h4_sellers: Result<Option<::std::string::String>, String>,
        max_h4_sells: Result<Option<::std::string::String>, String>,
        max_h4_trades: Result<Option<::std::string::String>, String>,
        max_h4_volume_in_usd: Result<Option<::std::string::String>, String>,
        max_m15_buy_volume_in_usd: Result<Option<::std::string::String>, String>,
        max_m15_buyers: Result<Option<::std::string::String>, String>,
        max_m15_buys: Result<Option<::std::string::String>, String>,
        max_m15_price_change_ratio: Result<Option<::std::string::String>, String>,
        max_m15_sell_volume_in_usd: Result<Option<::std::string::String>, String>,
        max_m15_sellers: Result<Option<::std::string::String>, String>,
        max_m15_sells: Result<Option<::std::string::String>, String>,
        max_m15_trades: Result<Option<::std::string::String>, String>,
        max_m15_volume_in_usd: Result<Option<::std::string::String>, String>,
        max_m1_buy_volume_in_usd: Result<Option<::std::string::String>, String>,
        max_m1_buyers: Result<Option<::std::string::String>, String>,
        max_m1_buys: Result<Option<::std::string::String>, String>,
        max_m1_price_change_ratio: Result<Option<::std::string::String>, String>,
        max_m1_sell_volume_in_usd: Result<Option<::std::string::String>, String>,
        max_m1_sellers: Result<Option<::std::string::String>, String>,
        max_m1_sells: Result<Option<::std::string::String>, String>,
        max_m1_trades: Result<Option<::std::string::String>, String>,
        max_m1_volume_in_usd: Result<Option<::std::string::String>, String>,
        max_m30_buy_volume_in_usd: Result<Option<::std::string::String>, String>,
        max_m30_buyers: Result<Option<::std::string::String>, String>,
        max_m30_buys: Result<Option<::std::string::String>, String>,
        max_m30_price_change_ratio: Result<Option<::std::string::String>, String>,
        max_m30_sell_volume_in_usd: Result<Option<::std::string::String>, String>,
        max_m30_sellers: Result<Option<::std::string::String>, String>,
        max_m30_sells: Result<Option<::std::string::String>, String>,
        max_m30_trades: Result<Option<::std::string::String>, String>,
        max_m30_volume_in_usd: Result<Option<::std::string::String>, String>,
        max_m5_buy_volume_in_usd: Result<Option<::std::string::String>, String>,
        max_m5_buyers: Result<Option<::std::string::String>, String>,
        max_m5_buys: Result<Option<::std::string::String>, String>,
        max_m5_price_change_ratio: Result<Option<::std::string::String>, String>,
        max_m5_sell_volume_in_usd: Result<Option<::std::string::String>, String>,
        max_m5_sellers: Result<Option<::std::string::String>, String>,
        max_m5_sells: Result<Option<::std::string::String>, String>,
        max_m5_trades: Result<Option<::std::string::String>, String>,
        max_m5_volume_in_usd: Result<Option<::std::string::String>, String>,
        min_h1_buy_volume_in_usd: Result<Option<::std::string::String>, String>,
        min_h1_buyers: Result<Option<::std::string::String>, String>,
        min_h1_buys: Result<Option<::std::string::String>, String>,
        min_h1_price_change_ratio: Result<Option<::std::string::String>, String>,
        min_h1_sell_volume_in_usd: Result<Option<::std::string::String>, String>,
        min_h1_sellers: Result<Option<::std::string::String>, String>,
        min_h1_sells: Result<Option<::std::string::String>, String>,
        min_h1_trades: Result<Option<::std::string::String>, String>,
        min_h1_volume_in_usd: Result<Option<::std::string::String>, String>,
        min_h24_buy_volume_in_usd: Result<Option<::std::string::String>, String>,
        min_h24_buyers: Result<Option<::std::string::String>, String>,
        min_h24_buys: Result<Option<::std::string::String>, String>,
        min_h24_price_change_ratio: Result<Option<::std::string::String>, String>,
        min_h24_sell_volume_in_usd: Result<Option<::std::string::String>, String>,
        min_h24_sellers: Result<Option<::std::string::String>, String>,
        min_h24_sells: Result<Option<::std::string::String>, String>,
        min_h24_trades: Result<Option<::std::string::String>, String>,
        min_h24_volume_in_usd: Result<Option<::std::string::String>, String>,
        min_h4_buy_volume_in_usd: Result<Option<::std::string::String>, String>,
        min_h4_buyers: Result<Option<::std::string::String>, String>,
        min_h4_buys: Result<Option<::std::string::String>, String>,
        min_h4_price_change_ratio: Result<Option<::std::string::String>, String>,
        min_h4_sell_volume_in_usd: Result<Option<::std::string::String>, String>,
        min_h4_sellers: Result<Option<::std::string::String>, String>,
        min_h4_sells: Result<Option<::std::string::String>, String>,
        min_h4_trades: Result<Option<::std::string::String>, String>,
        min_h4_volume_in_usd: Result<Option<::std::string::String>, String>,
        min_m15_buy_volume_in_usd: Result<Option<::std::string::String>, String>,
        min_m15_buyers: Result<Option<::std::string::String>, String>,
        min_m15_buys: Result<Option<::std::string::String>, String>,
        min_m15_price_change_ratio: Result<Option<::std::string::String>, String>,
        min_m15_sell_volume_in_usd: Result<Option<::std::string::String>, String>,
        min_m15_sellers: Result<Option<::std::string::String>, String>,
        min_m15_sells: Result<Option<::std::string::String>, String>,
        min_m15_trades: Result<Option<::std::string::String>, String>,
        min_m15_volume_in_usd: Result<Option<::std::string::String>, String>,
        min_m1_buy_volume_in_usd: Result<Option<::std::string::String>, String>,
        min_m1_buyers: Result<Option<::std::string::String>, String>,
        min_m1_buys: Result<Option<::std::string::String>, String>,
        min_m1_price_change_ratio: Result<Option<::std::string::String>, String>,
        min_m1_sell_volume_in_usd: Result<Option<::std::string::String>, String>,
        min_m1_sellers: Result<Option<::std::string::String>, String>,
        min_m1_sells: Result<Option<::std::string::String>, String>,
        min_m1_trades: Result<Option<::std::string::String>, String>,
        min_m1_volume_in_usd: Result<Option<::std::string::String>, String>,
        min_m30_buy_volume_in_usd: Result<Option<::std::string::String>, String>,
        min_m30_buyers: Result<Option<::std::string::String>, String>,
        min_m30_buys: Result<Option<::std::string::String>, String>,
        min_m30_price_change_ratio: Result<Option<::std::string::String>, String>,
        min_m30_sell_volume_in_usd: Result<Option<::std::string::String>, String>,
        min_m30_sellers: Result<Option<::std::string::String>, String>,
        min_m30_sells: Result<Option<::std::string::String>, String>,
        min_m30_trades: Result<Option<::std::string::String>, String>,
        min_m30_volume_in_usd: Result<Option<::std::string::String>, String>,
        min_m5_buy_volume_in_usd: Result<Option<::std::string::String>, String>,
        min_m5_buyers: Result<Option<::std::string::String>, String>,
        min_m5_buys: Result<Option<::std::string::String>, String>,
        min_m5_price_change_ratio: Result<Option<::std::string::String>, String>,
        min_m5_sell_volume_in_usd: Result<Option<::std::string::String>, String>,
        min_m5_sellers: Result<Option<::std::string::String>, String>,
        min_m5_sells: Result<Option<::std::string::String>, String>,
        min_m5_trades: Result<Option<::std::string::String>, String>,
        min_m5_volume_in_usd: Result<Option<::std::string::String>, String>,
        sort: Result<Option<types::ListTokenSort>, String>,
        sort_by: Result<Option<types::ListTokenSortBy>, String>,
    }
    impl<'a> ListToken<'a> {
        pub fn new(client: &'a super::Client) -> Self {
            Self {
                client: client,
                chain: Err("chain was not initialized".to_string()),
                cursor: Ok(None),
                direction: Ok(None),
                limit: Ok(None),
                max_h1_buy_volume_in_usd: Ok(None),
                max_h1_buyers: Ok(None),
                max_h1_buys: Ok(None),
                max_h1_price_change_ratio: Ok(None),
                max_h1_sell_volume_in_usd: Ok(None),
                max_h1_sellers: Ok(None),
                max_h1_sells: Ok(None),
                max_h1_trades: Ok(None),
                max_h1_volume_in_usd: Ok(None),
                max_h24_buy_volume_in_usd: Ok(None),
                max_h24_buyers: Ok(None),
                max_h24_buys: Ok(None),
                max_h24_price_change_ratio: Ok(None),
                max_h24_sell_volume_in_usd: Ok(None),
                max_h24_sellers: Ok(None),
                max_h24_sells: Ok(None),
                max_h24_trades: Ok(None),
                max_h24_volume_in_usd: Ok(None),
                max_h4_buy_volume_in_usd: Ok(None),
                max_h4_buyers: Ok(None),
                max_h4_buys: Ok(None),
                max_h4_price_change_ratio: Ok(None),
                max_h4_sell_volume_in_usd: Ok(None),
                max_h4_sellers: Ok(None),
                max_h4_sells: Ok(None),
                max_h4_trades: Ok(None),
                max_h4_volume_in_usd: Ok(None),
                max_m15_buy_volume_in_usd: Ok(None),
                max_m15_buyers: Ok(None),
                max_m15_buys: Ok(None),
                max_m15_price_change_ratio: Ok(None),
                max_m15_sell_volume_in_usd: Ok(None),
                max_m15_sellers: Ok(None),
                max_m15_sells: Ok(None),
                max_m15_trades: Ok(None),
                max_m15_volume_in_usd: Ok(None),
                max_m1_buy_volume_in_usd: Ok(None),
                max_m1_buyers: Ok(None),
                max_m1_buys: Ok(None),
                max_m1_price_change_ratio: Ok(None),
                max_m1_sell_volume_in_usd: Ok(None),
                max_m1_sellers: Ok(None),
                max_m1_sells: Ok(None),
                max_m1_trades: Ok(None),
                max_m1_volume_in_usd: Ok(None),
                max_m30_buy_volume_in_usd: Ok(None),
                max_m30_buyers: Ok(None),
                max_m30_buys: Ok(None),
                max_m30_price_change_ratio: Ok(None),
                max_m30_sell_volume_in_usd: Ok(None),
                max_m30_sellers: Ok(None),
                max_m30_sells: Ok(None),
                max_m30_trades: Ok(None),
                max_m30_volume_in_usd: Ok(None),
                max_m5_buy_volume_in_usd: Ok(None),
                max_m5_buyers: Ok(None),
                max_m5_buys: Ok(None),
                max_m5_price_change_ratio: Ok(None),
                max_m5_sell_volume_in_usd: Ok(None),
                max_m5_sellers: Ok(None),
                max_m5_sells: Ok(None),
                max_m5_trades: Ok(None),
                max_m5_volume_in_usd: Ok(None),
                min_h1_buy_volume_in_usd: Ok(None),
                min_h1_buyers: Ok(None),
                min_h1_buys: Ok(None),
                min_h1_price_change_ratio: Ok(None),
                min_h1_sell_volume_in_usd: Ok(None),
                min_h1_sellers: Ok(None),
                min_h1_sells: Ok(None),
                min_h1_trades: Ok(None),
                min_h1_volume_in_usd: Ok(None),
                min_h24_buy_volume_in_usd: Ok(None),
                min_h24_buyers: Ok(None),
                min_h24_buys: Ok(None),
                min_h24_price_change_ratio: Ok(None),
                min_h24_sell_volume_in_usd: Ok(None),
                min_h24_sellers: Ok(None),
                min_h24_sells: Ok(None),
                min_h24_trades: Ok(None),
                min_h24_volume_in_usd: Ok(None),
                min_h4_buy_volume_in_usd: Ok(None),
                min_h4_buyers: Ok(None),
                min_h4_buys: Ok(None),
                min_h4_price_change_ratio: Ok(None),
                min_h4_sell_volume_in_usd: Ok(None),
                min_h4_sellers: Ok(None),
                min_h4_sells: Ok(None),
                min_h4_trades: Ok(None),
                min_h4_volume_in_usd: Ok(None),
                min_m15_buy_volume_in_usd: Ok(None),
                min_m15_buyers: Ok(None),
                min_m15_buys: Ok(None),
                min_m15_price_change_ratio: Ok(None),
                min_m15_sell_volume_in_usd: Ok(None),
                min_m15_sellers: Ok(None),
                min_m15_sells: Ok(None),
                min_m15_trades: Ok(None),
                min_m15_volume_in_usd: Ok(None),
                min_m1_buy_volume_in_usd: Ok(None),
                min_m1_buyers: Ok(None),
                min_m1_buys: Ok(None),
                min_m1_price_change_ratio: Ok(None),
                min_m1_sell_volume_in_usd: Ok(None),
                min_m1_sellers: Ok(None),
                min_m1_sells: Ok(None),
                min_m1_trades: Ok(None),
                min_m1_volume_in_usd: Ok(None),
                min_m30_buy_volume_in_usd: Ok(None),
                min_m30_buyers: Ok(None),
                min_m30_buys: Ok(None),
                min_m30_price_change_ratio: Ok(None),
                min_m30_sell_volume_in_usd: Ok(None),
                min_m30_sellers: Ok(None),
                min_m30_sells: Ok(None),
                min_m30_trades: Ok(None),
                min_m30_volume_in_usd: Ok(None),
                min_m5_buy_volume_in_usd: Ok(None),
                min_m5_buyers: Ok(None),
                min_m5_buys: Ok(None),
                min_m5_price_change_ratio: Ok(None),
                min_m5_sell_volume_in_usd: Ok(None),
                min_m5_sellers: Ok(None),
                min_m5_sells: Ok(None),
                min_m5_trades: Ok(None),
                min_m5_volume_in_usd: Ok(None),
                sort: Ok(None),
                sort_by: Ok(None),
            }
        }
        pub fn chain<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::ChainSymbol>,
        {
            self.chain = value
                .try_into()
                .map_err(|_| "conversion to `ChainSymbol` for chain failed".to_string());
            self
        }
        pub fn cursor<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.cursor = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for cursor failed"
                        .to_string()
                });
            self
        }
        pub fn direction<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::ListTokenDirection>,
        {
            self.direction = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `ListTokenDirection` for direction failed".to_string()
                });
            self
        }
        pub fn limit<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::num::NonZeroU64>,
        {
            self.limit = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: num :: NonZeroU64` for limit failed"
                        .to_string()
                });
            self
        }
        pub fn max_h1_buy_volume_in_usd<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.max_h1_buy_volume_in_usd = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for max_h1_buy_volume_in_usd failed"
                        .to_string()
                });
            self
        }
        pub fn max_h1_buyers<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.max_h1_buyers = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for max_h1_buyers failed"
                        .to_string()
                });
            self
        }
        pub fn max_h1_buys<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.max_h1_buys = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for max_h1_buys failed"
                        .to_string()
                });
            self
        }
        pub fn max_h1_price_change_ratio<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.max_h1_price_change_ratio = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for max_h1_price_change_ratio failed"
                        .to_string()
                });
            self
        }
        pub fn max_h1_sell_volume_in_usd<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.max_h1_sell_volume_in_usd = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for max_h1_sell_volume_in_usd failed"
                        .to_string()
                });
            self
        }
        pub fn max_h1_sellers<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.max_h1_sellers = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for max_h1_sellers failed"
                        .to_string()
                });
            self
        }
        pub fn max_h1_sells<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.max_h1_sells = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for max_h1_sells failed"
                        .to_string()
                });
            self
        }
        pub fn max_h1_trades<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.max_h1_trades = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for max_h1_trades failed"
                        .to_string()
                });
            self
        }
        pub fn max_h1_volume_in_usd<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.max_h1_volume_in_usd = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for max_h1_volume_in_usd failed"
                        .to_string()
                });
            self
        }
        pub fn max_h24_buy_volume_in_usd<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.max_h24_buy_volume_in_usd = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for max_h24_buy_volume_in_usd failed"
                        .to_string()
                });
            self
        }
        pub fn max_h24_buyers<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.max_h24_buyers = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for max_h24_buyers failed"
                        .to_string()
                });
            self
        }
        pub fn max_h24_buys<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.max_h24_buys = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for max_h24_buys failed"
                        .to_string()
                });
            self
        }
        pub fn max_h24_price_change_ratio<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.max_h24_price_change_ratio = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for max_h24_price_change_ratio failed"
                        .to_string()
                });
            self
        }
        pub fn max_h24_sell_volume_in_usd<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.max_h24_sell_volume_in_usd = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for max_h24_sell_volume_in_usd failed"
                        .to_string()
                });
            self
        }
        pub fn max_h24_sellers<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.max_h24_sellers = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for max_h24_sellers failed"
                        .to_string()
                });
            self
        }
        pub fn max_h24_sells<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.max_h24_sells = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for max_h24_sells failed"
                        .to_string()
                });
            self
        }
        pub fn max_h24_trades<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.max_h24_trades = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for max_h24_trades failed"
                        .to_string()
                });
            self
        }
        pub fn max_h24_volume_in_usd<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.max_h24_volume_in_usd = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for max_h24_volume_in_usd failed"
                        .to_string()
                });
            self
        }
        pub fn max_h4_buy_volume_in_usd<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.max_h4_buy_volume_in_usd = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for max_h4_buy_volume_in_usd failed"
                        .to_string()
                });
            self
        }
        pub fn max_h4_buyers<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.max_h4_buyers = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for max_h4_buyers failed"
                        .to_string()
                });
            self
        }
        pub fn max_h4_buys<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.max_h4_buys = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for max_h4_buys failed"
                        .to_string()
                });
            self
        }
        pub fn max_h4_price_change_ratio<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.max_h4_price_change_ratio = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for max_h4_price_change_ratio failed"
                        .to_string()
                });
            self
        }
        pub fn max_h4_sell_volume_in_usd<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.max_h4_sell_volume_in_usd = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for max_h4_sell_volume_in_usd failed"
                        .to_string()
                });
            self
        }
        pub fn max_h4_sellers<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.max_h4_sellers = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for max_h4_sellers failed"
                        .to_string()
                });
            self
        }
        pub fn max_h4_sells<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.max_h4_sells = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for max_h4_sells failed"
                        .to_string()
                });
            self
        }
        pub fn max_h4_trades<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.max_h4_trades = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for max_h4_trades failed"
                        .to_string()
                });
            self
        }
        pub fn max_h4_volume_in_usd<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.max_h4_volume_in_usd = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for max_h4_volume_in_usd failed"
                        .to_string()
                });
            self
        }
        pub fn max_m15_buy_volume_in_usd<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.max_m15_buy_volume_in_usd = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for max_m15_buy_volume_in_usd failed"
                        .to_string()
                });
            self
        }
        pub fn max_m15_buyers<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.max_m15_buyers = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for max_m15_buyers failed"
                        .to_string()
                });
            self
        }
        pub fn max_m15_buys<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.max_m15_buys = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for max_m15_buys failed"
                        .to_string()
                });
            self
        }
        pub fn max_m15_price_change_ratio<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.max_m15_price_change_ratio = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for max_m15_price_change_ratio failed"
                        .to_string()
                });
            self
        }
        pub fn max_m15_sell_volume_in_usd<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.max_m15_sell_volume_in_usd = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for max_m15_sell_volume_in_usd failed"
                        .to_string()
                });
            self
        }
        pub fn max_m15_sellers<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.max_m15_sellers = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for max_m15_sellers failed"
                        .to_string()
                });
            self
        }
        pub fn max_m15_sells<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.max_m15_sells = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for max_m15_sells failed"
                        .to_string()
                });
            self
        }
        pub fn max_m15_trades<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.max_m15_trades = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for max_m15_trades failed"
                        .to_string()
                });
            self
        }
        pub fn max_m15_volume_in_usd<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.max_m15_volume_in_usd = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for max_m15_volume_in_usd failed"
                        .to_string()
                });
            self
        }
        pub fn max_m1_buy_volume_in_usd<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.max_m1_buy_volume_in_usd = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for max_m1_buy_volume_in_usd failed"
                        .to_string()
                });
            self
        }
        pub fn max_m1_buyers<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.max_m1_buyers = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for max_m1_buyers failed"
                        .to_string()
                });
            self
        }
        pub fn max_m1_buys<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.max_m1_buys = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for max_m1_buys failed"
                        .to_string()
                });
            self
        }
        pub fn max_m1_price_change_ratio<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.max_m1_price_change_ratio = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for max_m1_price_change_ratio failed"
                        .to_string()
                });
            self
        }
        pub fn max_m1_sell_volume_in_usd<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.max_m1_sell_volume_in_usd = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for max_m1_sell_volume_in_usd failed"
                        .to_string()
                });
            self
        }
        pub fn max_m1_sellers<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.max_m1_sellers = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for max_m1_sellers failed"
                        .to_string()
                });
            self
        }
        pub fn max_m1_sells<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.max_m1_sells = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for max_m1_sells failed"
                        .to_string()
                });
            self
        }
        pub fn max_m1_trades<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.max_m1_trades = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for max_m1_trades failed"
                        .to_string()
                });
            self
        }
        pub fn max_m1_volume_in_usd<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.max_m1_volume_in_usd = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for max_m1_volume_in_usd failed"
                        .to_string()
                });
            self
        }
        pub fn max_m30_buy_volume_in_usd<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.max_m30_buy_volume_in_usd = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for max_m30_buy_volume_in_usd failed"
                        .to_string()
                });
            self
        }
        pub fn max_m30_buyers<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.max_m30_buyers = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for max_m30_buyers failed"
                        .to_string()
                });
            self
        }
        pub fn max_m30_buys<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.max_m30_buys = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for max_m30_buys failed"
                        .to_string()
                });
            self
        }
        pub fn max_m30_price_change_ratio<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.max_m30_price_change_ratio = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for max_m30_price_change_ratio failed"
                        .to_string()
                });
            self
        }
        pub fn max_m30_sell_volume_in_usd<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.max_m30_sell_volume_in_usd = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for max_m30_sell_volume_in_usd failed"
                        .to_string()
                });
            self
        }
        pub fn max_m30_sellers<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.max_m30_sellers = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for max_m30_sellers failed"
                        .to_string()
                });
            self
        }
        pub fn max_m30_sells<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.max_m30_sells = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for max_m30_sells failed"
                        .to_string()
                });
            self
        }
        pub fn max_m30_trades<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.max_m30_trades = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for max_m30_trades failed"
                        .to_string()
                });
            self
        }
        pub fn max_m30_volume_in_usd<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.max_m30_volume_in_usd = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for max_m30_volume_in_usd failed"
                        .to_string()
                });
            self
        }
        pub fn max_m5_buy_volume_in_usd<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.max_m5_buy_volume_in_usd = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for max_m5_buy_volume_in_usd failed"
                        .to_string()
                });
            self
        }
        pub fn max_m5_buyers<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.max_m5_buyers = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for max_m5_buyers failed"
                        .to_string()
                });
            self
        }
        pub fn max_m5_buys<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.max_m5_buys = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for max_m5_buys failed"
                        .to_string()
                });
            self
        }
        pub fn max_m5_price_change_ratio<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.max_m5_price_change_ratio = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for max_m5_price_change_ratio failed"
                        .to_string()
                });
            self
        }
        pub fn max_m5_sell_volume_in_usd<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.max_m5_sell_volume_in_usd = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for max_m5_sell_volume_in_usd failed"
                        .to_string()
                });
            self
        }
        pub fn max_m5_sellers<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.max_m5_sellers = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for max_m5_sellers failed"
                        .to_string()
                });
            self
        }
        pub fn max_m5_sells<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.max_m5_sells = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for max_m5_sells failed"
                        .to_string()
                });
            self
        }
        pub fn max_m5_trades<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.max_m5_trades = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for max_m5_trades failed"
                        .to_string()
                });
            self
        }
        pub fn max_m5_volume_in_usd<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.max_m5_volume_in_usd = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for max_m5_volume_in_usd failed"
                        .to_string()
                });
            self
        }
        pub fn min_h1_buy_volume_in_usd<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.min_h1_buy_volume_in_usd = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for min_h1_buy_volume_in_usd failed"
                        .to_string()
                });
            self
        }
        pub fn min_h1_buyers<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.min_h1_buyers = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for min_h1_buyers failed"
                        .to_string()
                });
            self
        }
        pub fn min_h1_buys<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.min_h1_buys = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for min_h1_buys failed"
                        .to_string()
                });
            self
        }
        pub fn min_h1_price_change_ratio<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.min_h1_price_change_ratio = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for min_h1_price_change_ratio failed"
                        .to_string()
                });
            self
        }
        pub fn min_h1_sell_volume_in_usd<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.min_h1_sell_volume_in_usd = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for min_h1_sell_volume_in_usd failed"
                        .to_string()
                });
            self
        }
        pub fn min_h1_sellers<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.min_h1_sellers = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for min_h1_sellers failed"
                        .to_string()
                });
            self
        }
        pub fn min_h1_sells<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.min_h1_sells = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for min_h1_sells failed"
                        .to_string()
                });
            self
        }
        pub fn min_h1_trades<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.min_h1_trades = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for min_h1_trades failed"
                        .to_string()
                });
            self
        }
        pub fn min_h1_volume_in_usd<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.min_h1_volume_in_usd = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for min_h1_volume_in_usd failed"
                        .to_string()
                });
            self
        }
        pub fn min_h24_buy_volume_in_usd<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.min_h24_buy_volume_in_usd = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for min_h24_buy_volume_in_usd failed"
                        .to_string()
                });
            self
        }
        pub fn min_h24_buyers<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.min_h24_buyers = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for min_h24_buyers failed"
                        .to_string()
                });
            self
        }
        pub fn min_h24_buys<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.min_h24_buys = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for min_h24_buys failed"
                        .to_string()
                });
            self
        }
        pub fn min_h24_price_change_ratio<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.min_h24_price_change_ratio = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for min_h24_price_change_ratio failed"
                        .to_string()
                });
            self
        }
        pub fn min_h24_sell_volume_in_usd<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.min_h24_sell_volume_in_usd = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for min_h24_sell_volume_in_usd failed"
                        .to_string()
                });
            self
        }
        pub fn min_h24_sellers<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.min_h24_sellers = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for min_h24_sellers failed"
                        .to_string()
                });
            self
        }
        pub fn min_h24_sells<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.min_h24_sells = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for min_h24_sells failed"
                        .to_string()
                });
            self
        }
        pub fn min_h24_trades<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.min_h24_trades = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for min_h24_trades failed"
                        .to_string()
                });
            self
        }
        pub fn min_h24_volume_in_usd<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.min_h24_volume_in_usd = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for min_h24_volume_in_usd failed"
                        .to_string()
                });
            self
        }
        pub fn min_h4_buy_volume_in_usd<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.min_h4_buy_volume_in_usd = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for min_h4_buy_volume_in_usd failed"
                        .to_string()
                });
            self
        }
        pub fn min_h4_buyers<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.min_h4_buyers = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for min_h4_buyers failed"
                        .to_string()
                });
            self
        }
        pub fn min_h4_buys<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.min_h4_buys = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for min_h4_buys failed"
                        .to_string()
                });
            self
        }
        pub fn min_h4_price_change_ratio<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.min_h4_price_change_ratio = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for min_h4_price_change_ratio failed"
                        .to_string()
                });
            self
        }
        pub fn min_h4_sell_volume_in_usd<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.min_h4_sell_volume_in_usd = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for min_h4_sell_volume_in_usd failed"
                        .to_string()
                });
            self
        }
        pub fn min_h4_sellers<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.min_h4_sellers = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for min_h4_sellers failed"
                        .to_string()
                });
            self
        }
        pub fn min_h4_sells<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.min_h4_sells = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for min_h4_sells failed"
                        .to_string()
                });
            self
        }
        pub fn min_h4_trades<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.min_h4_trades = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for min_h4_trades failed"
                        .to_string()
                });
            self
        }
        pub fn min_h4_volume_in_usd<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.min_h4_volume_in_usd = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for min_h4_volume_in_usd failed"
                        .to_string()
                });
            self
        }
        pub fn min_m15_buy_volume_in_usd<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.min_m15_buy_volume_in_usd = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for min_m15_buy_volume_in_usd failed"
                        .to_string()
                });
            self
        }
        pub fn min_m15_buyers<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.min_m15_buyers = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for min_m15_buyers failed"
                        .to_string()
                });
            self
        }
        pub fn min_m15_buys<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.min_m15_buys = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for min_m15_buys failed"
                        .to_string()
                });
            self
        }
        pub fn min_m15_price_change_ratio<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.min_m15_price_change_ratio = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for min_m15_price_change_ratio failed"
                        .to_string()
                });
            self
        }
        pub fn min_m15_sell_volume_in_usd<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.min_m15_sell_volume_in_usd = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for min_m15_sell_volume_in_usd failed"
                        .to_string()
                });
            self
        }
        pub fn min_m15_sellers<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.min_m15_sellers = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for min_m15_sellers failed"
                        .to_string()
                });
            self
        }
        pub fn min_m15_sells<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.min_m15_sells = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for min_m15_sells failed"
                        .to_string()
                });
            self
        }
        pub fn min_m15_trades<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.min_m15_trades = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for min_m15_trades failed"
                        .to_string()
                });
            self
        }
        pub fn min_m15_volume_in_usd<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.min_m15_volume_in_usd = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for min_m15_volume_in_usd failed"
                        .to_string()
                });
            self
        }
        pub fn min_m1_buy_volume_in_usd<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.min_m1_buy_volume_in_usd = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for min_m1_buy_volume_in_usd failed"
                        .to_string()
                });
            self
        }
        pub fn min_m1_buyers<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.min_m1_buyers = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for min_m1_buyers failed"
                        .to_string()
                });
            self
        }
        pub fn min_m1_buys<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.min_m1_buys = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for min_m1_buys failed"
                        .to_string()
                });
            self
        }
        pub fn min_m1_price_change_ratio<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.min_m1_price_change_ratio = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for min_m1_price_change_ratio failed"
                        .to_string()
                });
            self
        }
        pub fn min_m1_sell_volume_in_usd<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.min_m1_sell_volume_in_usd = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for min_m1_sell_volume_in_usd failed"
                        .to_string()
                });
            self
        }
        pub fn min_m1_sellers<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.min_m1_sellers = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for min_m1_sellers failed"
                        .to_string()
                });
            self
        }
        pub fn min_m1_sells<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.min_m1_sells = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for min_m1_sells failed"
                        .to_string()
                });
            self
        }
        pub fn min_m1_trades<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.min_m1_trades = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for min_m1_trades failed"
                        .to_string()
                });
            self
        }
        pub fn min_m1_volume_in_usd<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.min_m1_volume_in_usd = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for min_m1_volume_in_usd failed"
                        .to_string()
                });
            self
        }
        pub fn min_m30_buy_volume_in_usd<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.min_m30_buy_volume_in_usd = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for min_m30_buy_volume_in_usd failed"
                        .to_string()
                });
            self
        }
        pub fn min_m30_buyers<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.min_m30_buyers = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for min_m30_buyers failed"
                        .to_string()
                });
            self
        }
        pub fn min_m30_buys<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.min_m30_buys = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for min_m30_buys failed"
                        .to_string()
                });
            self
        }
        pub fn min_m30_price_change_ratio<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.min_m30_price_change_ratio = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for min_m30_price_change_ratio failed"
                        .to_string()
                });
            self
        }
        pub fn min_m30_sell_volume_in_usd<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.min_m30_sell_volume_in_usd = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for min_m30_sell_volume_in_usd failed"
                        .to_string()
                });
            self
        }
        pub fn min_m30_sellers<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.min_m30_sellers = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for min_m30_sellers failed"
                        .to_string()
                });
            self
        }
        pub fn min_m30_sells<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.min_m30_sells = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for min_m30_sells failed"
                        .to_string()
                });
            self
        }
        pub fn min_m30_trades<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.min_m30_trades = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for min_m30_trades failed"
                        .to_string()
                });
            self
        }
        pub fn min_m30_volume_in_usd<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.min_m30_volume_in_usd = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for min_m30_volume_in_usd failed"
                        .to_string()
                });
            self
        }
        pub fn min_m5_buy_volume_in_usd<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.min_m5_buy_volume_in_usd = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for min_m5_buy_volume_in_usd failed"
                        .to_string()
                });
            self
        }
        pub fn min_m5_buyers<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.min_m5_buyers = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for min_m5_buyers failed"
                        .to_string()
                });
            self
        }
        pub fn min_m5_buys<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.min_m5_buys = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for min_m5_buys failed"
                        .to_string()
                });
            self
        }
        pub fn min_m5_price_change_ratio<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.min_m5_price_change_ratio = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for min_m5_price_change_ratio failed"
                        .to_string()
                });
            self
        }
        pub fn min_m5_sell_volume_in_usd<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.min_m5_sell_volume_in_usd = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for min_m5_sell_volume_in_usd failed"
                        .to_string()
                });
            self
        }
        pub fn min_m5_sellers<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.min_m5_sellers = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for min_m5_sellers failed"
                        .to_string()
                });
            self
        }
        pub fn min_m5_sells<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.min_m5_sells = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for min_m5_sells failed"
                        .to_string()
                });
            self
        }
        pub fn min_m5_trades<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.min_m5_trades = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for min_m5_trades failed"
                        .to_string()
                });
            self
        }
        pub fn min_m5_volume_in_usd<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.min_m5_volume_in_usd = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for min_m5_volume_in_usd failed"
                        .to_string()
                });
            self
        }
        pub fn sort<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::ListTokenSort>,
        {
            self.sort = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `ListTokenSort` for sort failed".to_string()
                });
            self
        }
        pub fn sort_by<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::ListTokenSortBy>,
        {
            self.sort_by = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `ListTokenSortBy` for sort_by failed".to_string()
                });
            self
        }
        ///Sends a `GET` request to `/v1/token/{chain}/list`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::TokenListPage>, Error<()>> {
            let Self {
                client,
                chain,
                cursor,
                direction,
                limit,
                max_h1_buy_volume_in_usd,
                max_h1_buyers,
                max_h1_buys,
                max_h1_price_change_ratio,
                max_h1_sell_volume_in_usd,
                max_h1_sellers,
                max_h1_sells,
                max_h1_trades,
                max_h1_volume_in_usd,
                max_h24_buy_volume_in_usd,
                max_h24_buyers,
                max_h24_buys,
                max_h24_price_change_ratio,
                max_h24_sell_volume_in_usd,
                max_h24_sellers,
                max_h24_sells,
                max_h24_trades,
                max_h24_volume_in_usd,
                max_h4_buy_volume_in_usd,
                max_h4_buyers,
                max_h4_buys,
                max_h4_price_change_ratio,
                max_h4_sell_volume_in_usd,
                max_h4_sellers,
                max_h4_sells,
                max_h4_trades,
                max_h4_volume_in_usd,
                max_m15_buy_volume_in_usd,
                max_m15_buyers,
                max_m15_buys,
                max_m15_price_change_ratio,
                max_m15_sell_volume_in_usd,
                max_m15_sellers,
                max_m15_sells,
                max_m15_trades,
                max_m15_volume_in_usd,
                max_m1_buy_volume_in_usd,
                max_m1_buyers,
                max_m1_buys,
                max_m1_price_change_ratio,
                max_m1_sell_volume_in_usd,
                max_m1_sellers,
                max_m1_sells,
                max_m1_trades,
                max_m1_volume_in_usd,
                max_m30_buy_volume_in_usd,
                max_m30_buyers,
                max_m30_buys,
                max_m30_price_change_ratio,
                max_m30_sell_volume_in_usd,
                max_m30_sellers,
                max_m30_sells,
                max_m30_trades,
                max_m30_volume_in_usd,
                max_m5_buy_volume_in_usd,
                max_m5_buyers,
                max_m5_buys,
                max_m5_price_change_ratio,
                max_m5_sell_volume_in_usd,
                max_m5_sellers,
                max_m5_sells,
                max_m5_trades,
                max_m5_volume_in_usd,
                min_h1_buy_volume_in_usd,
                min_h1_buyers,
                min_h1_buys,
                min_h1_price_change_ratio,
                min_h1_sell_volume_in_usd,
                min_h1_sellers,
                min_h1_sells,
                min_h1_trades,
                min_h1_volume_in_usd,
                min_h24_buy_volume_in_usd,
                min_h24_buyers,
                min_h24_buys,
                min_h24_price_change_ratio,
                min_h24_sell_volume_in_usd,
                min_h24_sellers,
                min_h24_sells,
                min_h24_trades,
                min_h24_volume_in_usd,
                min_h4_buy_volume_in_usd,
                min_h4_buyers,
                min_h4_buys,
                min_h4_price_change_ratio,
                min_h4_sell_volume_in_usd,
                min_h4_sellers,
                min_h4_sells,
                min_h4_trades,
                min_h4_volume_in_usd,
                min_m15_buy_volume_in_usd,
                min_m15_buyers,
                min_m15_buys,
                min_m15_price_change_ratio,
                min_m15_sell_volume_in_usd,
                min_m15_sellers,
                min_m15_sells,
                min_m15_trades,
                min_m15_volume_in_usd,
                min_m1_buy_volume_in_usd,
                min_m1_buyers,
                min_m1_buys,
                min_m1_price_change_ratio,
                min_m1_sell_volume_in_usd,
                min_m1_sellers,
                min_m1_sells,
                min_m1_trades,
                min_m1_volume_in_usd,
                min_m30_buy_volume_in_usd,
                min_m30_buyers,
                min_m30_buys,
                min_m30_price_change_ratio,
                min_m30_sell_volume_in_usd,
                min_m30_sellers,
                min_m30_sells,
                min_m30_trades,
                min_m30_volume_in_usd,
                min_m5_buy_volume_in_usd,
                min_m5_buyers,
                min_m5_buys,
                min_m5_price_change_ratio,
                min_m5_sell_volume_in_usd,
                min_m5_sellers,
                min_m5_sells,
                min_m5_trades,
                min_m5_volume_in_usd,
                sort,
                sort_by,
            } = self;
            let chain = chain.map_err(Error::InvalidRequest)?;
            let cursor = cursor.map_err(Error::InvalidRequest)?;
            let direction = direction.map_err(Error::InvalidRequest)?;
            let limit = limit.map_err(Error::InvalidRequest)?;
            let max_h1_buy_volume_in_usd = max_h1_buy_volume_in_usd
                .map_err(Error::InvalidRequest)?;
            let max_h1_buyers = max_h1_buyers.map_err(Error::InvalidRequest)?;
            let max_h1_buys = max_h1_buys.map_err(Error::InvalidRequest)?;
            let max_h1_price_change_ratio = max_h1_price_change_ratio
                .map_err(Error::InvalidRequest)?;
            let max_h1_sell_volume_in_usd = max_h1_sell_volume_in_usd
                .map_err(Error::InvalidRequest)?;
            let max_h1_sellers = max_h1_sellers.map_err(Error::InvalidRequest)?;
            let max_h1_sells = max_h1_sells.map_err(Error::InvalidRequest)?;
            let max_h1_trades = max_h1_trades.map_err(Error::InvalidRequest)?;
            let max_h1_volume_in_usd = max_h1_volume_in_usd
                .map_err(Error::InvalidRequest)?;
            let max_h24_buy_volume_in_usd = max_h24_buy_volume_in_usd
                .map_err(Error::InvalidRequest)?;
            let max_h24_buyers = max_h24_buyers.map_err(Error::InvalidRequest)?;
            let max_h24_buys = max_h24_buys.map_err(Error::InvalidRequest)?;
            let max_h24_price_change_ratio = max_h24_price_change_ratio
                .map_err(Error::InvalidRequest)?;
            let max_h24_sell_volume_in_usd = max_h24_sell_volume_in_usd
                .map_err(Error::InvalidRequest)?;
            let max_h24_sellers = max_h24_sellers.map_err(Error::InvalidRequest)?;
            let max_h24_sells = max_h24_sells.map_err(Error::InvalidRequest)?;
            let max_h24_trades = max_h24_trades.map_err(Error::InvalidRequest)?;
            let max_h24_volume_in_usd = max_h24_volume_in_usd
                .map_err(Error::InvalidRequest)?;
            let max_h4_buy_volume_in_usd = max_h4_buy_volume_in_usd
                .map_err(Error::InvalidRequest)?;
            let max_h4_buyers = max_h4_buyers.map_err(Error::InvalidRequest)?;
            let max_h4_buys = max_h4_buys.map_err(Error::InvalidRequest)?;
            let max_h4_price_change_ratio = max_h4_price_change_ratio
                .map_err(Error::InvalidRequest)?;
            let max_h4_sell_volume_in_usd = max_h4_sell_volume_in_usd
                .map_err(Error::InvalidRequest)?;
            let max_h4_sellers = max_h4_sellers.map_err(Error::InvalidRequest)?;
            let max_h4_sells = max_h4_sells.map_err(Error::InvalidRequest)?;
            let max_h4_trades = max_h4_trades.map_err(Error::InvalidRequest)?;
            let max_h4_volume_in_usd = max_h4_volume_in_usd
                .map_err(Error::InvalidRequest)?;
            let max_m15_buy_volume_in_usd = max_m15_buy_volume_in_usd
                .map_err(Error::InvalidRequest)?;
            let max_m15_buyers = max_m15_buyers.map_err(Error::InvalidRequest)?;
            let max_m15_buys = max_m15_buys.map_err(Error::InvalidRequest)?;
            let max_m15_price_change_ratio = max_m15_price_change_ratio
                .map_err(Error::InvalidRequest)?;
            let max_m15_sell_volume_in_usd = max_m15_sell_volume_in_usd
                .map_err(Error::InvalidRequest)?;
            let max_m15_sellers = max_m15_sellers.map_err(Error::InvalidRequest)?;
            let max_m15_sells = max_m15_sells.map_err(Error::InvalidRequest)?;
            let max_m15_trades = max_m15_trades.map_err(Error::InvalidRequest)?;
            let max_m15_volume_in_usd = max_m15_volume_in_usd
                .map_err(Error::InvalidRequest)?;
            let max_m1_buy_volume_in_usd = max_m1_buy_volume_in_usd
                .map_err(Error::InvalidRequest)?;
            let max_m1_buyers = max_m1_buyers.map_err(Error::InvalidRequest)?;
            let max_m1_buys = max_m1_buys.map_err(Error::InvalidRequest)?;
            let max_m1_price_change_ratio = max_m1_price_change_ratio
                .map_err(Error::InvalidRequest)?;
            let max_m1_sell_volume_in_usd = max_m1_sell_volume_in_usd
                .map_err(Error::InvalidRequest)?;
            let max_m1_sellers = max_m1_sellers.map_err(Error::InvalidRequest)?;
            let max_m1_sells = max_m1_sells.map_err(Error::InvalidRequest)?;
            let max_m1_trades = max_m1_trades.map_err(Error::InvalidRequest)?;
            let max_m1_volume_in_usd = max_m1_volume_in_usd
                .map_err(Error::InvalidRequest)?;
            let max_m30_buy_volume_in_usd = max_m30_buy_volume_in_usd
                .map_err(Error::InvalidRequest)?;
            let max_m30_buyers = max_m30_buyers.map_err(Error::InvalidRequest)?;
            let max_m30_buys = max_m30_buys.map_err(Error::InvalidRequest)?;
            let max_m30_price_change_ratio = max_m30_price_change_ratio
                .map_err(Error::InvalidRequest)?;
            let max_m30_sell_volume_in_usd = max_m30_sell_volume_in_usd
                .map_err(Error::InvalidRequest)?;
            let max_m30_sellers = max_m30_sellers.map_err(Error::InvalidRequest)?;
            let max_m30_sells = max_m30_sells.map_err(Error::InvalidRequest)?;
            let max_m30_trades = max_m30_trades.map_err(Error::InvalidRequest)?;
            let max_m30_volume_in_usd = max_m30_volume_in_usd
                .map_err(Error::InvalidRequest)?;
            let max_m5_buy_volume_in_usd = max_m5_buy_volume_in_usd
                .map_err(Error::InvalidRequest)?;
            let max_m5_buyers = max_m5_buyers.map_err(Error::InvalidRequest)?;
            let max_m5_buys = max_m5_buys.map_err(Error::InvalidRequest)?;
            let max_m5_price_change_ratio = max_m5_price_change_ratio
                .map_err(Error::InvalidRequest)?;
            let max_m5_sell_volume_in_usd = max_m5_sell_volume_in_usd
                .map_err(Error::InvalidRequest)?;
            let max_m5_sellers = max_m5_sellers.map_err(Error::InvalidRequest)?;
            let max_m5_sells = max_m5_sells.map_err(Error::InvalidRequest)?;
            let max_m5_trades = max_m5_trades.map_err(Error::InvalidRequest)?;
            let max_m5_volume_in_usd = max_m5_volume_in_usd
                .map_err(Error::InvalidRequest)?;
            let min_h1_buy_volume_in_usd = min_h1_buy_volume_in_usd
                .map_err(Error::InvalidRequest)?;
            let min_h1_buyers = min_h1_buyers.map_err(Error::InvalidRequest)?;
            let min_h1_buys = min_h1_buys.map_err(Error::InvalidRequest)?;
            let min_h1_price_change_ratio = min_h1_price_change_ratio
                .map_err(Error::InvalidRequest)?;
            let min_h1_sell_volume_in_usd = min_h1_sell_volume_in_usd
                .map_err(Error::InvalidRequest)?;
            let min_h1_sellers = min_h1_sellers.map_err(Error::InvalidRequest)?;
            let min_h1_sells = min_h1_sells.map_err(Error::InvalidRequest)?;
            let min_h1_trades = min_h1_trades.map_err(Error::InvalidRequest)?;
            let min_h1_volume_in_usd = min_h1_volume_in_usd
                .map_err(Error::InvalidRequest)?;
            let min_h24_buy_volume_in_usd = min_h24_buy_volume_in_usd
                .map_err(Error::InvalidRequest)?;
            let min_h24_buyers = min_h24_buyers.map_err(Error::InvalidRequest)?;
            let min_h24_buys = min_h24_buys.map_err(Error::InvalidRequest)?;
            let min_h24_price_change_ratio = min_h24_price_change_ratio
                .map_err(Error::InvalidRequest)?;
            let min_h24_sell_volume_in_usd = min_h24_sell_volume_in_usd
                .map_err(Error::InvalidRequest)?;
            let min_h24_sellers = min_h24_sellers.map_err(Error::InvalidRequest)?;
            let min_h24_sells = min_h24_sells.map_err(Error::InvalidRequest)?;
            let min_h24_trades = min_h24_trades.map_err(Error::InvalidRequest)?;
            let min_h24_volume_in_usd = min_h24_volume_in_usd
                .map_err(Error::InvalidRequest)?;
            let min_h4_buy_volume_in_usd = min_h4_buy_volume_in_usd
                .map_err(Error::InvalidRequest)?;
            let min_h4_buyers = min_h4_buyers.map_err(Error::InvalidRequest)?;
            let min_h4_buys = min_h4_buys.map_err(Error::InvalidRequest)?;
            let min_h4_price_change_ratio = min_h4_price_change_ratio
                .map_err(Error::InvalidRequest)?;
            let min_h4_sell_volume_in_usd = min_h4_sell_volume_in_usd
                .map_err(Error::InvalidRequest)?;
            let min_h4_sellers = min_h4_sellers.map_err(Error::InvalidRequest)?;
            let min_h4_sells = min_h4_sells.map_err(Error::InvalidRequest)?;
            let min_h4_trades = min_h4_trades.map_err(Error::InvalidRequest)?;
            let min_h4_volume_in_usd = min_h4_volume_in_usd
                .map_err(Error::InvalidRequest)?;
            let min_m15_buy_volume_in_usd = min_m15_buy_volume_in_usd
                .map_err(Error::InvalidRequest)?;
            let min_m15_buyers = min_m15_buyers.map_err(Error::InvalidRequest)?;
            let min_m15_buys = min_m15_buys.map_err(Error::InvalidRequest)?;
            let min_m15_price_change_ratio = min_m15_price_change_ratio
                .map_err(Error::InvalidRequest)?;
            let min_m15_sell_volume_in_usd = min_m15_sell_volume_in_usd
                .map_err(Error::InvalidRequest)?;
            let min_m15_sellers = min_m15_sellers.map_err(Error::InvalidRequest)?;
            let min_m15_sells = min_m15_sells.map_err(Error::InvalidRequest)?;
            let min_m15_trades = min_m15_trades.map_err(Error::InvalidRequest)?;
            let min_m15_volume_in_usd = min_m15_volume_in_usd
                .map_err(Error::InvalidRequest)?;
            let min_m1_buy_volume_in_usd = min_m1_buy_volume_in_usd
                .map_err(Error::InvalidRequest)?;
            let min_m1_buyers = min_m1_buyers.map_err(Error::InvalidRequest)?;
            let min_m1_buys = min_m1_buys.map_err(Error::InvalidRequest)?;
            let min_m1_price_change_ratio = min_m1_price_change_ratio
                .map_err(Error::InvalidRequest)?;
            let min_m1_sell_volume_in_usd = min_m1_sell_volume_in_usd
                .map_err(Error::InvalidRequest)?;
            let min_m1_sellers = min_m1_sellers.map_err(Error::InvalidRequest)?;
            let min_m1_sells = min_m1_sells.map_err(Error::InvalidRequest)?;
            let min_m1_trades = min_m1_trades.map_err(Error::InvalidRequest)?;
            let min_m1_volume_in_usd = min_m1_volume_in_usd
                .map_err(Error::InvalidRequest)?;
            let min_m30_buy_volume_in_usd = min_m30_buy_volume_in_usd
                .map_err(Error::InvalidRequest)?;
            let min_m30_buyers = min_m30_buyers.map_err(Error::InvalidRequest)?;
            let min_m30_buys = min_m30_buys.map_err(Error::InvalidRequest)?;
            let min_m30_price_change_ratio = min_m30_price_change_ratio
                .map_err(Error::InvalidRequest)?;
            let min_m30_sell_volume_in_usd = min_m30_sell_volume_in_usd
                .map_err(Error::InvalidRequest)?;
            let min_m30_sellers = min_m30_sellers.map_err(Error::InvalidRequest)?;
            let min_m30_sells = min_m30_sells.map_err(Error::InvalidRequest)?;
            let min_m30_trades = min_m30_trades.map_err(Error::InvalidRequest)?;
            let min_m30_volume_in_usd = min_m30_volume_in_usd
                .map_err(Error::InvalidRequest)?;
            let min_m5_buy_volume_in_usd = min_m5_buy_volume_in_usd
                .map_err(Error::InvalidRequest)?;
            let min_m5_buyers = min_m5_buyers.map_err(Error::InvalidRequest)?;
            let min_m5_buys = min_m5_buys.map_err(Error::InvalidRequest)?;
            let min_m5_price_change_ratio = min_m5_price_change_ratio
                .map_err(Error::InvalidRequest)?;
            let min_m5_sell_volume_in_usd = min_m5_sell_volume_in_usd
                .map_err(Error::InvalidRequest)?;
            let min_m5_sellers = min_m5_sellers.map_err(Error::InvalidRequest)?;
            let min_m5_sells = min_m5_sells.map_err(Error::InvalidRequest)?;
            let min_m5_trades = min_m5_trades.map_err(Error::InvalidRequest)?;
            let min_m5_volume_in_usd = min_m5_volume_in_usd
                .map_err(Error::InvalidRequest)?;
            let sort = sort.map_err(Error::InvalidRequest)?;
            let sort_by = sort_by.map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v1/token/{}/list", client.baseurl, encode_path(& chain.to_string()),
            );
            let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
            header_map
                .append(
                    ::reqwest::header::HeaderName::from_static("api-version"),
                    ::reqwest::header::HeaderValue::from_static(
                        super::Client::api_version(),
                    ),
                );
            #[allow(unused_mut)]
            let mut request = client
                .client
                .get(url)
                .header(
                    ::reqwest::header::ACCEPT,
                    ::reqwest::header::HeaderValue::from_static("application/json"),
                )
                .query(&progenitor_middleware_client::QueryParam::new("cursor", &cursor))
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "direction",
                        &direction,
                    ),
                )
                .query(&progenitor_middleware_client::QueryParam::new("limit", &limit))
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "max_h1_buy_volume_in_usd",
                        &max_h1_buy_volume_in_usd,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "max_h1_buyers",
                        &max_h1_buyers,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "max_h1_buys",
                        &max_h1_buys,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "max_h1_price_change_ratio",
                        &max_h1_price_change_ratio,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "max_h1_sell_volume_in_usd",
                        &max_h1_sell_volume_in_usd,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "max_h1_sellers",
                        &max_h1_sellers,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "max_h1_sells",
                        &max_h1_sells,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "max_h1_trades",
                        &max_h1_trades,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "max_h1_volume_in_usd",
                        &max_h1_volume_in_usd,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "max_h24_buy_volume_in_usd",
                        &max_h24_buy_volume_in_usd,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "max_h24_buyers",
                        &max_h24_buyers,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "max_h24_buys",
                        &max_h24_buys,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "max_h24_price_change_ratio",
                        &max_h24_price_change_ratio,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "max_h24_sell_volume_in_usd",
                        &max_h24_sell_volume_in_usd,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "max_h24_sellers",
                        &max_h24_sellers,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "max_h24_sells",
                        &max_h24_sells,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "max_h24_trades",
                        &max_h24_trades,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "max_h24_volume_in_usd",
                        &max_h24_volume_in_usd,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "max_h4_buy_volume_in_usd",
                        &max_h4_buy_volume_in_usd,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "max_h4_buyers",
                        &max_h4_buyers,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "max_h4_buys",
                        &max_h4_buys,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "max_h4_price_change_ratio",
                        &max_h4_price_change_ratio,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "max_h4_sell_volume_in_usd",
                        &max_h4_sell_volume_in_usd,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "max_h4_sellers",
                        &max_h4_sellers,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "max_h4_sells",
                        &max_h4_sells,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "max_h4_trades",
                        &max_h4_trades,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "max_h4_volume_in_usd",
                        &max_h4_volume_in_usd,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "max_m15_buy_volume_in_usd",
                        &max_m15_buy_volume_in_usd,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "max_m15_buyers",
                        &max_m15_buyers,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "max_m15_buys",
                        &max_m15_buys,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "max_m15_price_change_ratio",
                        &max_m15_price_change_ratio,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "max_m15_sell_volume_in_usd",
                        &max_m15_sell_volume_in_usd,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "max_m15_sellers",
                        &max_m15_sellers,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "max_m15_sells",
                        &max_m15_sells,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "max_m15_trades",
                        &max_m15_trades,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "max_m15_volume_in_usd",
                        &max_m15_volume_in_usd,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "max_m1_buy_volume_in_usd",
                        &max_m1_buy_volume_in_usd,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "max_m1_buyers",
                        &max_m1_buyers,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "max_m1_buys",
                        &max_m1_buys,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "max_m1_price_change_ratio",
                        &max_m1_price_change_ratio,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "max_m1_sell_volume_in_usd",
                        &max_m1_sell_volume_in_usd,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "max_m1_sellers",
                        &max_m1_sellers,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "max_m1_sells",
                        &max_m1_sells,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "max_m1_trades",
                        &max_m1_trades,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "max_m1_volume_in_usd",
                        &max_m1_volume_in_usd,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "max_m30_buy_volume_in_usd",
                        &max_m30_buy_volume_in_usd,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "max_m30_buyers",
                        &max_m30_buyers,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "max_m30_buys",
                        &max_m30_buys,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "max_m30_price_change_ratio",
                        &max_m30_price_change_ratio,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "max_m30_sell_volume_in_usd",
                        &max_m30_sell_volume_in_usd,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "max_m30_sellers",
                        &max_m30_sellers,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "max_m30_sells",
                        &max_m30_sells,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "max_m30_trades",
                        &max_m30_trades,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "max_m30_volume_in_usd",
                        &max_m30_volume_in_usd,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "max_m5_buy_volume_in_usd",
                        &max_m5_buy_volume_in_usd,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "max_m5_buyers",
                        &max_m5_buyers,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "max_m5_buys",
                        &max_m5_buys,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "max_m5_price_change_ratio",
                        &max_m5_price_change_ratio,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "max_m5_sell_volume_in_usd",
                        &max_m5_sell_volume_in_usd,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "max_m5_sellers",
                        &max_m5_sellers,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "max_m5_sells",
                        &max_m5_sells,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "max_m5_trades",
                        &max_m5_trades,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "max_m5_volume_in_usd",
                        &max_m5_volume_in_usd,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "min_h1_buy_volume_in_usd",
                        &min_h1_buy_volume_in_usd,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "min_h1_buyers",
                        &min_h1_buyers,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "min_h1_buys",
                        &min_h1_buys,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "min_h1_price_change_ratio",
                        &min_h1_price_change_ratio,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "min_h1_sell_volume_in_usd",
                        &min_h1_sell_volume_in_usd,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "min_h1_sellers",
                        &min_h1_sellers,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "min_h1_sells",
                        &min_h1_sells,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "min_h1_trades",
                        &min_h1_trades,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "min_h1_volume_in_usd",
                        &min_h1_volume_in_usd,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "min_h24_buy_volume_in_usd",
                        &min_h24_buy_volume_in_usd,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "min_h24_buyers",
                        &min_h24_buyers,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "min_h24_buys",
                        &min_h24_buys,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "min_h24_price_change_ratio",
                        &min_h24_price_change_ratio,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "min_h24_sell_volume_in_usd",
                        &min_h24_sell_volume_in_usd,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "min_h24_sellers",
                        &min_h24_sellers,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "min_h24_sells",
                        &min_h24_sells,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "min_h24_trades",
                        &min_h24_trades,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "min_h24_volume_in_usd",
                        &min_h24_volume_in_usd,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "min_h4_buy_volume_in_usd",
                        &min_h4_buy_volume_in_usd,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "min_h4_buyers",
                        &min_h4_buyers,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "min_h4_buys",
                        &min_h4_buys,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "min_h4_price_change_ratio",
                        &min_h4_price_change_ratio,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "min_h4_sell_volume_in_usd",
                        &min_h4_sell_volume_in_usd,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "min_h4_sellers",
                        &min_h4_sellers,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "min_h4_sells",
                        &min_h4_sells,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "min_h4_trades",
                        &min_h4_trades,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "min_h4_volume_in_usd",
                        &min_h4_volume_in_usd,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "min_m15_buy_volume_in_usd",
                        &min_m15_buy_volume_in_usd,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "min_m15_buyers",
                        &min_m15_buyers,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "min_m15_buys",
                        &min_m15_buys,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "min_m15_price_change_ratio",
                        &min_m15_price_change_ratio,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "min_m15_sell_volume_in_usd",
                        &min_m15_sell_volume_in_usd,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "min_m15_sellers",
                        &min_m15_sellers,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "min_m15_sells",
                        &min_m15_sells,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "min_m15_trades",
                        &min_m15_trades,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "min_m15_volume_in_usd",
                        &min_m15_volume_in_usd,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "min_m1_buy_volume_in_usd",
                        &min_m1_buy_volume_in_usd,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "min_m1_buyers",
                        &min_m1_buyers,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "min_m1_buys",
                        &min_m1_buys,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "min_m1_price_change_ratio",
                        &min_m1_price_change_ratio,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "min_m1_sell_volume_in_usd",
                        &min_m1_sell_volume_in_usd,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "min_m1_sellers",
                        &min_m1_sellers,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "min_m1_sells",
                        &min_m1_sells,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "min_m1_trades",
                        &min_m1_trades,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "min_m1_volume_in_usd",
                        &min_m1_volume_in_usd,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "min_m30_buy_volume_in_usd",
                        &min_m30_buy_volume_in_usd,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "min_m30_buyers",
                        &min_m30_buyers,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "min_m30_buys",
                        &min_m30_buys,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "min_m30_price_change_ratio",
                        &min_m30_price_change_ratio,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "min_m30_sell_volume_in_usd",
                        &min_m30_sell_volume_in_usd,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "min_m30_sellers",
                        &min_m30_sellers,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "min_m30_sells",
                        &min_m30_sells,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "min_m30_trades",
                        &min_m30_trades,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "min_m30_volume_in_usd",
                        &min_m30_volume_in_usd,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "min_m5_buy_volume_in_usd",
                        &min_m5_buy_volume_in_usd,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "min_m5_buyers",
                        &min_m5_buyers,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "min_m5_buys",
                        &min_m5_buys,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "min_m5_price_change_ratio",
                        &min_m5_price_change_ratio,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "min_m5_sell_volume_in_usd",
                        &min_m5_sell_volume_in_usd,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "min_m5_sellers",
                        &min_m5_sellers,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "min_m5_sells",
                        &min_m5_sells,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "min_m5_trades",
                        &min_m5_trades,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "min_m5_volume_in_usd",
                        &min_m5_volume_in_usd,
                    ),
                )
                .query(&progenitor_middleware_client::QueryParam::new("sort", &sort))
                .query(
                    &progenitor_middleware_client::QueryParam::new("sortBy", &sort_by),
                )
                .headers(header_map)
                .build()?;
            let info = OperationInfo {
                operation_id: "list_token",
            };
            client.pre(&mut request, &info).await?;
            let result = client.exec(request, &info).await;
            client.post(&result, &info).await?;
            let response = result?;
            match response.status().as_u16() {
                200u16 => ResponseValue::from_response::<()>(response).await,
                _ => Err(Error::UnexpectedResponse(response)),
            }
        }
    }
    /**Builder for [`Client::get_market_data_multi`]

[`Client::get_market_data_multi`]: super::Client::get_market_data_multi*/
    #[derive(Debug, Clone)]
    pub struct GetMarketDataMulti<'a> {
        client: &'a super::Client,
        chain: Result<types::ChainSymbol, String>,
        token_addresses: Result<::std::string::String, String>,
    }
    impl<'a> GetMarketDataMulti<'a> {
        pub fn new(client: &'a super::Client) -> Self {
            Self {
                client: client,
                chain: Err("chain was not initialized".to_string()),
                token_addresses: Err("token_addresses was not initialized".to_string()),
            }
        }
        pub fn chain<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::ChainSymbol>,
        {
            self.chain = value
                .try_into()
                .map_err(|_| "conversion to `ChainSymbol` for chain failed".to_string());
            self
        }
        pub fn token_addresses<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.token_addresses = value
                .try_into()
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for token_addresses failed"
                        .to_string()
                });
            self
        }
        ///Sends a `GET` request to `/v1/token/{chain}/marketData/multi`
        pub async fn send(
            self,
        ) -> Result<
            ResponseValue<
                ::std::collections::HashMap<
                    ::std::string::String,
                    types::TokenMarketData,
                >,
            >,
            Error<()>,
        > {
            let Self { client, chain, token_addresses } = self;
            let chain = chain.map_err(Error::InvalidRequest)?;
            let token_addresses = token_addresses.map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v1/token/{}/marketData/multi", client.baseurl, encode_path(& chain
                .to_string()),
            );
            let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
            header_map
                .append(
                    ::reqwest::header::HeaderName::from_static("api-version"),
                    ::reqwest::header::HeaderValue::from_static(
                        super::Client::api_version(),
                    ),
                );
            #[allow(unused_mut)]
            let mut request = client
                .client
                .get(url)
                .header(
                    ::reqwest::header::ACCEPT,
                    ::reqwest::header::HeaderValue::from_static("application/json"),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "tokenAddresses",
                        &token_addresses,
                    ),
                )
                .headers(header_map)
                .build()?;
            let info = OperationInfo {
                operation_id: "get_market_data_multi",
            };
            client.pre(&mut request, &info).await?;
            let result = client.exec(request, &info).await;
            client.post(&result, &info).await?;
            let response = result?;
            match response.status().as_u16() {
                200u16 => ResponseValue::from_response::<()>(response).await,
                _ => Err(Error::UnexpectedResponse(response)),
            }
        }
    }
    /**Builder for [`Client::get_metadata_multi`]

[`Client::get_metadata_multi`]: super::Client::get_metadata_multi*/
    #[derive(Debug, Clone)]
    pub struct GetMetadataMulti<'a> {
        client: &'a super::Client,
        chain: Result<types::ChainSymbol, String>,
        token_addresses: Result<::std::string::String, String>,
    }
    impl<'a> GetMetadataMulti<'a> {
        pub fn new(client: &'a super::Client) -> Self {
            Self {
                client: client,
                chain: Err("chain was not initialized".to_string()),
                token_addresses: Err("token_addresses was not initialized".to_string()),
            }
        }
        pub fn chain<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::ChainSymbol>,
        {
            self.chain = value
                .try_into()
                .map_err(|_| "conversion to `ChainSymbol` for chain failed".to_string());
            self
        }
        pub fn token_addresses<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.token_addresses = value
                .try_into()
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for token_addresses failed"
                        .to_string()
                });
            self
        }
        ///Sends a `GET` request to `/v1/token/{chain}/metadata/multi`
        pub async fn send(
            self,
        ) -> Result<
            ResponseValue<
                ::std::collections::HashMap<::std::string::String, types::TokenMetadata>,
            >,
            Error<()>,
        > {
            let Self { client, chain, token_addresses } = self;
            let chain = chain.map_err(Error::InvalidRequest)?;
            let token_addresses = token_addresses.map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v1/token/{}/metadata/multi", client.baseurl, encode_path(& chain
                .to_string()),
            );
            let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
            header_map
                .append(
                    ::reqwest::header::HeaderName::from_static("api-version"),
                    ::reqwest::header::HeaderValue::from_static(
                        super::Client::api_version(),
                    ),
                );
            #[allow(unused_mut)]
            let mut request = client
                .client
                .get(url)
                .header(
                    ::reqwest::header::ACCEPT,
                    ::reqwest::header::HeaderValue::from_static("application/json"),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "tokenAddresses",
                        &token_addresses,
                    ),
                )
                .headers(header_map)
                .build()?;
            let info = OperationInfo {
                operation_id: "get_metadata_multi",
            };
            client.pre(&mut request, &info).await?;
            let result = client.exec(request, &info).await;
            client.post(&result, &info).await?;
            let response = result?;
            match response.status().as_u16() {
                200u16 => ResponseValue::from_response::<()>(response).await,
                _ => Err(Error::UnexpectedResponse(response)),
            }
        }
    }
    /**Builder for [`Client::get_tokens`]

[`Client::get_tokens`]: super::Client::get_tokens*/
    #[derive(Debug, Clone)]
    pub struct GetTokens<'a> {
        client: &'a super::Client,
        chain: Result<types::ChainSymbol, String>,
        filter_by: Result<Option<::std::vec::Vec<types::FilterCondition>>, String>,
        sort_by: Result<Option<types::GetTokensSortBy>, String>,
        sort_direction: Result<Option<types::GetTokensSortDirection>, String>,
        token_addresses: Result<::std::string::String, String>,
    }
    impl<'a> GetTokens<'a> {
        pub fn new(client: &'a super::Client) -> Self {
            Self {
                client: client,
                chain: Err("chain was not initialized".to_string()),
                filter_by: Ok(None),
                sort_by: Ok(None),
                sort_direction: Ok(None),
                token_addresses: Err("token_addresses was not initialized".to_string()),
            }
        }
        pub fn chain<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::ChainSymbol>,
        {
            self.chain = value
                .try_into()
                .map_err(|_| "conversion to `ChainSymbol` for chain failed".to_string());
            self
        }
        pub fn filter_by<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::vec::Vec<types::FilterCondition>>,
        {
            self.filter_by = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: vec :: Vec < FilterCondition >` for filter_by failed"
                        .to_string()
                });
            self
        }
        pub fn sort_by<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::GetTokensSortBy>,
        {
            self.sort_by = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `GetTokensSortBy` for sort_by failed".to_string()
                });
            self
        }
        pub fn sort_direction<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::GetTokensSortDirection>,
        {
            self.sort_direction = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `GetTokensSortDirection` for sort_direction failed"
                        .to_string()
                });
            self
        }
        pub fn token_addresses<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.token_addresses = value
                .try_into()
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for token_addresses failed"
                        .to_string()
                });
            self
        }
        ///Sends a `GET` request to `/v1/token/{chain}/multi`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<::std::vec::Vec<types::Token>>, Error<()>> {
            let Self {
                client,
                chain,
                filter_by,
                sort_by,
                sort_direction,
                token_addresses,
            } = self;
            let chain = chain.map_err(Error::InvalidRequest)?;
            let filter_by = filter_by.map_err(Error::InvalidRequest)?;
            let sort_by = sort_by.map_err(Error::InvalidRequest)?;
            let sort_direction = sort_direction.map_err(Error::InvalidRequest)?;
            let token_addresses = token_addresses.map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v1/token/{}/multi", client.baseurl, encode_path(& chain.to_string()),
            );
            let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
            header_map
                .append(
                    ::reqwest::header::HeaderName::from_static("api-version"),
                    ::reqwest::header::HeaderValue::from_static(
                        super::Client::api_version(),
                    ),
                );
            #[allow(unused_mut)]
            let mut request = client
                .client
                .get(url)
                .header(
                    ::reqwest::header::ACCEPT,
                    ::reqwest::header::HeaderValue::from_static("application/json"),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "filterBy",
                        &filter_by,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new("sortBy", &sort_by),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "sortDirection",
                        &sort_direction,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "tokenAddresses",
                        &token_addresses,
                    ),
                )
                .headers(header_map)
                .build()?;
            let info = OperationInfo {
                operation_id: "get_tokens",
            };
            client.pre(&mut request, &info).await?;
            let result = client.exec(request, &info).await;
            client.post(&result, &info).await?;
            let response = result?;
            match response.status().as_u16() {
                200u16 => ResponseValue::from_response::<()>(response).await,
                _ => Err(Error::UnexpectedResponse(response)),
            }
        }
    }
    /**Builder for [`Client::get_pair_candles`]

[`Client::get_pair_candles`]: super::Client::get_pair_candles*/
    #[derive(Debug, Clone)]
    pub struct GetPairCandles<'a> {
        client: &'a super::Client,
        chain: Result<types::ChainSymbol, String>,
        pair: Result<::std::string::String, String>,
        from: Result<Option<i64>, String>,
        limit: Result<Option<i64>, String>,
        price_type: Result<Option<types::PriceType>, String>,
        resolution: Result<types::Resolution, String>,
        to: Result<Option<i64>, String>,
    }
    impl<'a> GetPairCandles<'a> {
        pub fn new(client: &'a super::Client) -> Self {
            Self {
                client: client,
                chain: Err("chain was not initialized".to_string()),
                pair: Err("pair was not initialized".to_string()),
                from: Ok(None),
                limit: Ok(None),
                price_type: Ok(None),
                resolution: Err("resolution was not initialized".to_string()),
                to: Ok(None),
            }
        }
        pub fn chain<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::ChainSymbol>,
        {
            self.chain = value
                .try_into()
                .map_err(|_| "conversion to `ChainSymbol` for chain failed".to_string());
            self
        }
        pub fn pair<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.pair = value
                .try_into()
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for pair failed"
                        .to_string()
                });
            self
        }
        pub fn from<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<i64>,
        {
            self.from = value
                .try_into()
                .map(Some)
                .map_err(|_| "conversion to `i64` for from failed".to_string());
            self
        }
        pub fn limit<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<i64>,
        {
            self.limit = value
                .try_into()
                .map(Some)
                .map_err(|_| "conversion to `i64` for limit failed".to_string());
            self
        }
        pub fn price_type<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::PriceType>,
        {
            self.price_type = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `PriceType` for price_type failed".to_string()
                });
            self
        }
        pub fn resolution<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::Resolution>,
        {
            self.resolution = value
                .try_into()
                .map_err(|_| {
                    "conversion to `Resolution` for resolution failed".to_string()
                });
            self
        }
        pub fn to<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<i64>,
        {
            self.to = value
                .try_into()
                .map(Some)
                .map_err(|_| "conversion to `i64` for to failed".to_string());
            self
        }
        ///Sends a `GET` request to `/v1/token/{chain}/pair/{pair}/candles`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<::std::vec::Vec<types::Candle>>, Error<()>> {
            let Self { client, chain, pair, from, limit, price_type, resolution, to } = self;
            let chain = chain.map_err(Error::InvalidRequest)?;
            let pair = pair.map_err(Error::InvalidRequest)?;
            let from = from.map_err(Error::InvalidRequest)?;
            let limit = limit.map_err(Error::InvalidRequest)?;
            let price_type = price_type.map_err(Error::InvalidRequest)?;
            let resolution = resolution.map_err(Error::InvalidRequest)?;
            let to = to.map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v1/token/{}/pair/{}/candles", client.baseurl, encode_path(& chain
                .to_string()), encode_path(& pair.to_string()),
            );
            let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
            header_map
                .append(
                    ::reqwest::header::HeaderName::from_static("api-version"),
                    ::reqwest::header::HeaderValue::from_static(
                        super::Client::api_version(),
                    ),
                );
            #[allow(unused_mut)]
            let mut request = client
                .client
                .get(url)
                .header(
                    ::reqwest::header::ACCEPT,
                    ::reqwest::header::HeaderValue::from_static("application/json"),
                )
                .query(&progenitor_middleware_client::QueryParam::new("from", &from))
                .query(&progenitor_middleware_client::QueryParam::new("limit", &limit))
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "priceType",
                        &price_type,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "resolution",
                        &resolution,
                    ),
                )
                .query(&progenitor_middleware_client::QueryParam::new("to", &to))
                .headers(header_map)
                .build()?;
            let info = OperationInfo {
                operation_id: "get_pair_candles",
            };
            client.pre(&mut request, &info).await?;
            let result = client.exec(request, &info).await;
            client.post(&result, &info).await?;
            let response = result?;
            match response.status().as_u16() {
                200u16 => ResponseValue::from_response::<()>(response).await,
                _ => Err(Error::UnexpectedResponse(response)),
            }
        }
    }
    /**Builder for [`Client::get_pool_candles`]

[`Client::get_pool_candles`]: super::Client::get_pool_candles*/
    #[derive(Debug, Clone)]
    pub struct GetPoolCandles<'a> {
        client: &'a super::Client,
        chain: Result<types::ChainSymbol, String>,
        pool_address: Result<::std::string::String, String>,
        from: Result<Option<i64>, String>,
        limit: Result<Option<i64>, String>,
        price_type: Result<Option<types::PriceType>, String>,
        resolution: Result<types::Resolution, String>,
        to: Result<Option<i64>, String>,
    }
    impl<'a> GetPoolCandles<'a> {
        pub fn new(client: &'a super::Client) -> Self {
            Self {
                client: client,
                chain: Err("chain was not initialized".to_string()),
                pool_address: Err("pool_address was not initialized".to_string()),
                from: Ok(None),
                limit: Ok(None),
                price_type: Ok(None),
                resolution: Err("resolution was not initialized".to_string()),
                to: Ok(None),
            }
        }
        pub fn chain<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::ChainSymbol>,
        {
            self.chain = value
                .try_into()
                .map_err(|_| "conversion to `ChainSymbol` for chain failed".to_string());
            self
        }
        pub fn pool_address<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.pool_address = value
                .try_into()
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for pool_address failed"
                        .to_string()
                });
            self
        }
        pub fn from<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<i64>,
        {
            self.from = value
                .try_into()
                .map(Some)
                .map_err(|_| "conversion to `i64` for from failed".to_string());
            self
        }
        pub fn limit<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<i64>,
        {
            self.limit = value
                .try_into()
                .map(Some)
                .map_err(|_| "conversion to `i64` for limit failed".to_string());
            self
        }
        pub fn price_type<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::PriceType>,
        {
            self.price_type = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `PriceType` for price_type failed".to_string()
                });
            self
        }
        pub fn resolution<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::Resolution>,
        {
            self.resolution = value
                .try_into()
                .map_err(|_| {
                    "conversion to `Resolution` for resolution failed".to_string()
                });
            self
        }
        pub fn to<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<i64>,
        {
            self.to = value
                .try_into()
                .map(Some)
                .map_err(|_| "conversion to `i64` for to failed".to_string());
            self
        }
        ///Sends a `GET` request to `/v1/token/{chain}/pool/{poolAddress}/candles`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<::std::vec::Vec<types::Candle>>, Error<()>> {
            let Self {
                client,
                chain,
                pool_address,
                from,
                limit,
                price_type,
                resolution,
                to,
            } = self;
            let chain = chain.map_err(Error::InvalidRequest)?;
            let pool_address = pool_address.map_err(Error::InvalidRequest)?;
            let from = from.map_err(Error::InvalidRequest)?;
            let limit = limit.map_err(Error::InvalidRequest)?;
            let price_type = price_type.map_err(Error::InvalidRequest)?;
            let resolution = resolution.map_err(Error::InvalidRequest)?;
            let to = to.map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v1/token/{}/pool/{}/candles", client.baseurl, encode_path(& chain
                .to_string()), encode_path(& pool_address.to_string()),
            );
            let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
            header_map
                .append(
                    ::reqwest::header::HeaderName::from_static("api-version"),
                    ::reqwest::header::HeaderValue::from_static(
                        super::Client::api_version(),
                    ),
                );
            #[allow(unused_mut)]
            let mut request = client
                .client
                .get(url)
                .header(
                    ::reqwest::header::ACCEPT,
                    ::reqwest::header::HeaderValue::from_static("application/json"),
                )
                .query(&progenitor_middleware_client::QueryParam::new("from", &from))
                .query(&progenitor_middleware_client::QueryParam::new("limit", &limit))
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "priceType",
                        &price_type,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "resolution",
                        &resolution,
                    ),
                )
                .query(&progenitor_middleware_client::QueryParam::new("to", &to))
                .headers(header_map)
                .build()?;
            let info = OperationInfo {
                operation_id: "get_pool_candles",
            };
            client.pre(&mut request, &info).await?;
            let result = client.exec(request, &info).await;
            client.post(&result, &info).await?;
            let response = result?;
            match response.status().as_u16() {
                200u16 => ResponseValue::from_response::<()>(response).await,
                _ => Err(Error::UnexpectedResponse(response)),
            }
        }
    }
    /**Builder for [`Client::get_stats_multi`]

[`Client::get_stats_multi`]: super::Client::get_stats_multi*/
    #[derive(Debug, Clone)]
    pub struct GetStatsMulti<'a> {
        client: &'a super::Client,
        chain: Result<types::ChainSymbol, String>,
        token_addresses: Result<::std::string::String, String>,
    }
    impl<'a> GetStatsMulti<'a> {
        pub fn new(client: &'a super::Client) -> Self {
            Self {
                client: client,
                chain: Err("chain was not initialized".to_string()),
                token_addresses: Err("token_addresses was not initialized".to_string()),
            }
        }
        pub fn chain<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::ChainSymbol>,
        {
            self.chain = value
                .try_into()
                .map_err(|_| "conversion to `ChainSymbol` for chain failed".to_string());
            self
        }
        pub fn token_addresses<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.token_addresses = value
                .try_into()
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for token_addresses failed"
                        .to_string()
                });
            self
        }
        ///Sends a `GET` request to `/v1/token/{chain}/stats/multi`
        pub async fn send(
            self,
        ) -> Result<
            ResponseValue<
                ::std::collections::HashMap<::std::string::String, types::TokenStat>,
            >,
            Error<()>,
        > {
            let Self { client, chain, token_addresses } = self;
            let chain = chain.map_err(Error::InvalidRequest)?;
            let token_addresses = token_addresses.map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v1/token/{}/stats/multi", client.baseurl, encode_path(& chain
                .to_string()),
            );
            let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
            header_map
                .append(
                    ::reqwest::header::HeaderName::from_static("api-version"),
                    ::reqwest::header::HeaderValue::from_static(
                        super::Client::api_version(),
                    ),
                );
            #[allow(unused_mut)]
            let mut request = client
                .client
                .get(url)
                .header(
                    ::reqwest::header::ACCEPT,
                    ::reqwest::header::HeaderValue::from_static("application/json"),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "tokenAddresses",
                        &token_addresses,
                    ),
                )
                .headers(header_map)
                .build()?;
            let info = OperationInfo {
                operation_id: "get_stats_multi",
            };
            client.pre(&mut request, &info).await?;
            let result = client.exec(request, &info).await;
            client.post(&result, &info).await?;
            let response = result?;
            match response.status().as_u16() {
                200u16 => ResponseValue::from_response::<()>(response).await,
                _ => Err(Error::UnexpectedResponse(response)),
            }
        }
    }
    /**Builder for [`Client::get_token`]

[`Client::get_token`]: super::Client::get_token*/
    #[derive(Debug, Clone)]
    pub struct GetToken<'a> {
        client: &'a super::Client,
        chain: Result<types::ChainSymbol, String>,
        token_address: Result<::std::string::String, String>,
    }
    impl<'a> GetToken<'a> {
        pub fn new(client: &'a super::Client) -> Self {
            Self {
                client: client,
                chain: Err("chain was not initialized".to_string()),
                token_address: Err("token_address was not initialized".to_string()),
            }
        }
        pub fn chain<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::ChainSymbol>,
        {
            self.chain = value
                .try_into()
                .map_err(|_| "conversion to `ChainSymbol` for chain failed".to_string());
            self
        }
        pub fn token_address<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.token_address = value
                .try_into()
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for token_address failed"
                        .to_string()
                });
            self
        }
        ///Sends a `GET` request to `/v1/token/{chain}/{tokenAddress}`
        pub async fn send(self) -> Result<ResponseValue<types::Token>, Error<()>> {
            let Self { client, chain, token_address } = self;
            let chain = chain.map_err(Error::InvalidRequest)?;
            let token_address = token_address.map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v1/token/{}/{}", client.baseurl, encode_path(& chain.to_string()),
                encode_path(& token_address.to_string()),
            );
            let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
            header_map
                .append(
                    ::reqwest::header::HeaderName::from_static("api-version"),
                    ::reqwest::header::HeaderValue::from_static(
                        super::Client::api_version(),
                    ),
                );
            #[allow(unused_mut)]
            let mut request = client
                .client
                .get(url)
                .header(
                    ::reqwest::header::ACCEPT,
                    ::reqwest::header::HeaderValue::from_static("application/json"),
                )
                .headers(header_map)
                .build()?;
            let info = OperationInfo {
                operation_id: "get_token",
            };
            client.pre(&mut request, &info).await?;
            let result = client.exec(request, &info).await;
            client.post(&result, &info).await?;
            let response = result?;
            match response.status().as_u16() {
                200u16 => ResponseValue::from_response::<()>(response).await,
                _ => Err(Error::UnexpectedResponse(response)),
            }
        }
    }
    /**Builder for [`Client::get_candles`]

[`Client::get_candles`]: super::Client::get_candles*/
    #[derive(Debug, Clone)]
    pub struct GetCandles<'a> {
        client: &'a super::Client,
        chain: Result<types::ChainSymbol, String>,
        token_address: Result<::std::string::String, String>,
        from: Result<Option<i64>, String>,
        limit: Result<Option<i64>, String>,
        price_type: Result<Option<types::PriceType>, String>,
        resolution: Result<types::Resolution, String>,
        to: Result<Option<i64>, String>,
    }
    impl<'a> GetCandles<'a> {
        pub fn new(client: &'a super::Client) -> Self {
            Self {
                client: client,
                chain: Err("chain was not initialized".to_string()),
                token_address: Err("token_address was not initialized".to_string()),
                from: Ok(None),
                limit: Ok(None),
                price_type: Ok(None),
                resolution: Err("resolution was not initialized".to_string()),
                to: Ok(None),
            }
        }
        pub fn chain<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::ChainSymbol>,
        {
            self.chain = value
                .try_into()
                .map_err(|_| "conversion to `ChainSymbol` for chain failed".to_string());
            self
        }
        pub fn token_address<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.token_address = value
                .try_into()
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for token_address failed"
                        .to_string()
                });
            self
        }
        pub fn from<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<i64>,
        {
            self.from = value
                .try_into()
                .map(Some)
                .map_err(|_| "conversion to `i64` for from failed".to_string());
            self
        }
        pub fn limit<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<i64>,
        {
            self.limit = value
                .try_into()
                .map(Some)
                .map_err(|_| "conversion to `i64` for limit failed".to_string());
            self
        }
        pub fn price_type<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::PriceType>,
        {
            self.price_type = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `PriceType` for price_type failed".to_string()
                });
            self
        }
        pub fn resolution<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::Resolution>,
        {
            self.resolution = value
                .try_into()
                .map_err(|_| {
                    "conversion to `Resolution` for resolution failed".to_string()
                });
            self
        }
        pub fn to<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<i64>,
        {
            self.to = value
                .try_into()
                .map(Some)
                .map_err(|_| "conversion to `i64` for to failed".to_string());
            self
        }
        ///Sends a `GET` request to `/v1/token/{chain}/{tokenAddress}/candles`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<::std::vec::Vec<types::Candle>>, Error<()>> {
            let Self {
                client,
                chain,
                token_address,
                from,
                limit,
                price_type,
                resolution,
                to,
            } = self;
            let chain = chain.map_err(Error::InvalidRequest)?;
            let token_address = token_address.map_err(Error::InvalidRequest)?;
            let from = from.map_err(Error::InvalidRequest)?;
            let limit = limit.map_err(Error::InvalidRequest)?;
            let price_type = price_type.map_err(Error::InvalidRequest)?;
            let resolution = resolution.map_err(Error::InvalidRequest)?;
            let to = to.map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v1/token/{}/{}/candles", client.baseurl, encode_path(& chain
                .to_string()), encode_path(& token_address.to_string()),
            );
            let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
            header_map
                .append(
                    ::reqwest::header::HeaderName::from_static("api-version"),
                    ::reqwest::header::HeaderValue::from_static(
                        super::Client::api_version(),
                    ),
                );
            #[allow(unused_mut)]
            let mut request = client
                .client
                .get(url)
                .header(
                    ::reqwest::header::ACCEPT,
                    ::reqwest::header::HeaderValue::from_static("application/json"),
                )
                .query(&progenitor_middleware_client::QueryParam::new("from", &from))
                .query(&progenitor_middleware_client::QueryParam::new("limit", &limit))
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "priceType",
                        &price_type,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "resolution",
                        &resolution,
                    ),
                )
                .query(&progenitor_middleware_client::QueryParam::new("to", &to))
                .headers(header_map)
                .build()?;
            let info = OperationInfo {
                operation_id: "get_candles",
            };
            client.pre(&mut request, &info).await?;
            let result = client.exec(request, &info).await;
            client.post(&result, &info).await?;
            let response = result?;
            match response.status().as_u16() {
                200u16 => ResponseValue::from_response::<()>(response).await,
                _ => Err(Error::UnexpectedResponse(response)),
            }
        }
    }
    /**Builder for [`Client::get_creation`]

[`Client::get_creation`]: super::Client::get_creation*/
    #[derive(Debug, Clone)]
    pub struct GetCreation<'a> {
        client: &'a super::Client,
        chain: Result<types::ChainSymbol, String>,
        token_address: Result<::std::string::String, String>,
    }
    impl<'a> GetCreation<'a> {
        pub fn new(client: &'a super::Client) -> Self {
            Self {
                client: client,
                chain: Err("chain was not initialized".to_string()),
                token_address: Err("token_address was not initialized".to_string()),
            }
        }
        pub fn chain<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::ChainSymbol>,
        {
            self.chain = value
                .try_into()
                .map_err(|_| "conversion to `ChainSymbol` for chain failed".to_string());
            self
        }
        pub fn token_address<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.token_address = value
                .try_into()
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for token_address failed"
                        .to_string()
                });
            self
        }
        ///Sends a `GET` request to `/v1/token/{chain}/{tokenAddress}/creation`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::TokenCreationDto>, Error<()>> {
            let Self { client, chain, token_address } = self;
            let chain = chain.map_err(Error::InvalidRequest)?;
            let token_address = token_address.map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v1/token/{}/{}/creation", client.baseurl, encode_path(& chain
                .to_string()), encode_path(& token_address.to_string()),
            );
            let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
            header_map
                .append(
                    ::reqwest::header::HeaderName::from_static("api-version"),
                    ::reqwest::header::HeaderValue::from_static(
                        super::Client::api_version(),
                    ),
                );
            #[allow(unused_mut)]
            let mut request = client
                .client
                .get(url)
                .header(
                    ::reqwest::header::ACCEPT,
                    ::reqwest::header::HeaderValue::from_static("application/json"),
                )
                .headers(header_map)
                .build()?;
            let info = OperationInfo {
                operation_id: "get_creation",
            };
            client.pre(&mut request, &info).await?;
            let result = client.exec(request, &info).await;
            client.post(&result, &info).await?;
            let response = result?;
            match response.status().as_u16() {
                200u16 => ResponseValue::from_response::<()>(response).await,
                _ => Err(Error::UnexpectedResponse(response)),
            }
        }
    }
    /**Builder for [`Client::get_holders`]

[`Client::get_holders`]: super::Client::get_holders*/
    #[derive(Debug, Clone)]
    pub struct GetHolders<'a> {
        client: &'a super::Client,
        chain: Result<types::ChainSymbol, String>,
        token_address: Result<::std::string::String, String>,
        cursor: Result<Option<::std::string::String>, String>,
        direction: Result<Option<types::GetHoldersDirection>, String>,
        limit: Result<Option<::std::num::NonZeroU64>, String>,
    }
    impl<'a> GetHolders<'a> {
        pub fn new(client: &'a super::Client) -> Self {
            Self {
                client: client,
                chain: Err("chain was not initialized".to_string()),
                token_address: Err("token_address was not initialized".to_string()),
                cursor: Ok(None),
                direction: Ok(None),
                limit: Ok(None),
            }
        }
        pub fn chain<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::ChainSymbol>,
        {
            self.chain = value
                .try_into()
                .map_err(|_| "conversion to `ChainSymbol` for chain failed".to_string());
            self
        }
        pub fn token_address<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.token_address = value
                .try_into()
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for token_address failed"
                        .to_string()
                });
            self
        }
        pub fn cursor<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.cursor = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for cursor failed"
                        .to_string()
                });
            self
        }
        pub fn direction<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::GetHoldersDirection>,
        {
            self.direction = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `GetHoldersDirection` for direction failed"
                        .to_string()
                });
            self
        }
        pub fn limit<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::num::NonZeroU64>,
        {
            self.limit = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: num :: NonZeroU64` for limit failed"
                        .to_string()
                });
            self
        }
        ///Sends a `GET` request to `/v1/token/{chain}/{tokenAddress}/holders`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::TokenHolderPage>, Error<()>> {
            let Self { client, chain, token_address, cursor, direction, limit } = self;
            let chain = chain.map_err(Error::InvalidRequest)?;
            let token_address = token_address.map_err(Error::InvalidRequest)?;
            let cursor = cursor.map_err(Error::InvalidRequest)?;
            let direction = direction.map_err(Error::InvalidRequest)?;
            let limit = limit.map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v1/token/{}/{}/holders", client.baseurl, encode_path(& chain
                .to_string()), encode_path(& token_address.to_string()),
            );
            let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
            header_map
                .append(
                    ::reqwest::header::HeaderName::from_static("api-version"),
                    ::reqwest::header::HeaderValue::from_static(
                        super::Client::api_version(),
                    ),
                );
            #[allow(unused_mut)]
            let mut request = client
                .client
                .get(url)
                .header(
                    ::reqwest::header::ACCEPT,
                    ::reqwest::header::HeaderValue::from_static("application/json"),
                )
                .query(&progenitor_middleware_client::QueryParam::new("cursor", &cursor))
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "direction",
                        &direction,
                    ),
                )
                .query(&progenitor_middleware_client::QueryParam::new("limit", &limit))
                .headers(header_map)
                .build()?;
            let info = OperationInfo {
                operation_id: "get_holders",
            };
            client.pre(&mut request, &info).await?;
            let result = client.exec(request, &info).await;
            client.post(&result, &info).await?;
            let response = result?;
            match response.status().as_u16() {
                200u16 => ResponseValue::from_response::<()>(response).await,
                _ => Err(Error::UnexpectedResponse(response)),
            }
        }
    }
    /**Builder for [`Client::get_holders_multi`]

[`Client::get_holders_multi`]: super::Client::get_holders_multi*/
    #[derive(Debug, Clone)]
    pub struct GetHoldersMulti<'a> {
        client: &'a super::Client,
        chain: Result<types::ChainSymbol, String>,
        token_address: Result<::std::string::String, String>,
        wallet_addresses: Result<::std::string::String, String>,
    }
    impl<'a> GetHoldersMulti<'a> {
        pub fn new(client: &'a super::Client) -> Self {
            Self {
                client: client,
                chain: Err("chain was not initialized".to_string()),
                token_address: Err("token_address was not initialized".to_string()),
                wallet_addresses: Err("wallet_addresses was not initialized".to_string()),
            }
        }
        pub fn chain<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::ChainSymbol>,
        {
            self.chain = value
                .try_into()
                .map_err(|_| "conversion to `ChainSymbol` for chain failed".to_string());
            self
        }
        pub fn token_address<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.token_address = value
                .try_into()
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for token_address failed"
                        .to_string()
                });
            self
        }
        pub fn wallet_addresses<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.wallet_addresses = value
                .try_into()
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for wallet_addresses failed"
                        .to_string()
                });
            self
        }
        ///Sends a `GET` request to `/v1/token/{chain}/{tokenAddress}/holders/multi`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<::std::vec::Vec<types::TokenHolder>>, Error<()>> {
            let Self { client, chain, token_address, wallet_addresses } = self;
            let chain = chain.map_err(Error::InvalidRequest)?;
            let token_address = token_address.map_err(Error::InvalidRequest)?;
            let wallet_addresses = wallet_addresses.map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v1/token/{}/{}/holders/multi", client.baseurl, encode_path(& chain
                .to_string()), encode_path(& token_address.to_string()),
            );
            let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
            header_map
                .append(
                    ::reqwest::header::HeaderName::from_static("api-version"),
                    ::reqwest::header::HeaderValue::from_static(
                        super::Client::api_version(),
                    ),
                );
            #[allow(unused_mut)]
            let mut request = client
                .client
                .get(url)
                .header(
                    ::reqwest::header::ACCEPT,
                    ::reqwest::header::HeaderValue::from_static("application/json"),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "walletAddresses",
                        &wallet_addresses,
                    ),
                )
                .headers(header_map)
                .build()?;
            let info = OperationInfo {
                operation_id: "get_holders_multi",
            };
            client.pre(&mut request, &info).await?;
            let result = client.exec(request, &info).await;
            client.post(&result, &info).await?;
            let response = result?;
            match response.status().as_u16() {
                200u16 => ResponseValue::from_response::<()>(response).await,
                _ => Err(Error::UnexpectedResponse(response)),
            }
        }
    }
    /**Builder for [`Client::get_token_liquidity_snapshots`]

[`Client::get_token_liquidity_snapshots`]: super::Client::get_token_liquidity_snapshots*/
    #[derive(Debug, Clone)]
    pub struct GetTokenLiquiditySnapshots<'a> {
        client: &'a super::Client,
        chain: Result<types::ChainSymbol, String>,
        token_address: Result<::std::string::String, String>,
        cursor: Result<Option<::std::string::String>, String>,
        direction: Result<Option<types::GetTokenLiquiditySnapshotsDirection>, String>,
        limit: Result<Option<::std::num::NonZeroU64>, String>,
        time: Result<Option<i64>, String>,
    }
    impl<'a> GetTokenLiquiditySnapshots<'a> {
        pub fn new(client: &'a super::Client) -> Self {
            Self {
                client: client,
                chain: Err("chain was not initialized".to_string()),
                token_address: Err("token_address was not initialized".to_string()),
                cursor: Ok(None),
                direction: Ok(None),
                limit: Ok(None),
                time: Ok(None),
            }
        }
        pub fn chain<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::ChainSymbol>,
        {
            self.chain = value
                .try_into()
                .map_err(|_| "conversion to `ChainSymbol` for chain failed".to_string());
            self
        }
        pub fn token_address<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.token_address = value
                .try_into()
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for token_address failed"
                        .to_string()
                });
            self
        }
        pub fn cursor<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.cursor = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for cursor failed"
                        .to_string()
                });
            self
        }
        pub fn direction<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::GetTokenLiquiditySnapshotsDirection>,
        {
            self.direction = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `GetTokenLiquiditySnapshotsDirection` for direction failed"
                        .to_string()
                });
            self
        }
        pub fn limit<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::num::NonZeroU64>,
        {
            self.limit = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: num :: NonZeroU64` for limit failed"
                        .to_string()
                });
            self
        }
        pub fn time<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<i64>,
        {
            self.time = value
                .try_into()
                .map(Some)
                .map_err(|_| "conversion to `i64` for time failed".to_string());
            self
        }
        ///Sends a `GET` request to `/v1/token/{chain}/{tokenAddress}/liquiditySnapshots`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::TokenLiquiditySnapshotPage>, Error<()>> {
            let Self { client, chain, token_address, cursor, direction, limit, time } = self;
            let chain = chain.map_err(Error::InvalidRequest)?;
            let token_address = token_address.map_err(Error::InvalidRequest)?;
            let cursor = cursor.map_err(Error::InvalidRequest)?;
            let direction = direction.map_err(Error::InvalidRequest)?;
            let limit = limit.map_err(Error::InvalidRequest)?;
            let time = time.map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v1/token/{}/{}/liquiditySnapshots", client.baseurl, encode_path(&
                chain.to_string()), encode_path(& token_address.to_string()),
            );
            let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
            header_map
                .append(
                    ::reqwest::header::HeaderName::from_static("api-version"),
                    ::reqwest::header::HeaderValue::from_static(
                        super::Client::api_version(),
                    ),
                );
            #[allow(unused_mut)]
            let mut request = client
                .client
                .get(url)
                .header(
                    ::reqwest::header::ACCEPT,
                    ::reqwest::header::HeaderValue::from_static("application/json"),
                )
                .query(&progenitor_middleware_client::QueryParam::new("cursor", &cursor))
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "direction",
                        &direction,
                    ),
                )
                .query(&progenitor_middleware_client::QueryParam::new("limit", &limit))
                .query(&progenitor_middleware_client::QueryParam::new("time", &time))
                .headers(header_map)
                .build()?;
            let info = OperationInfo {
                operation_id: "get_token_liquidity_snapshots",
            };
            client.pre(&mut request, &info).await?;
            let result = client.exec(request, &info).await;
            client.post(&result, &info).await?;
            let response = result?;
            match response.status().as_u16() {
                200u16 => ResponseValue::from_response::<()>(response).await,
                _ => Err(Error::UnexpectedResponse(response)),
            }
        }
    }
    /**Builder for [`Client::get_market_data`]

[`Client::get_market_data`]: super::Client::get_market_data*/
    #[derive(Debug, Clone)]
    pub struct GetMarketData<'a> {
        client: &'a super::Client,
        chain: Result<types::ChainSymbol, String>,
        token_address: Result<::std::string::String, String>,
    }
    impl<'a> GetMarketData<'a> {
        pub fn new(client: &'a super::Client) -> Self {
            Self {
                client: client,
                chain: Err("chain was not initialized".to_string()),
                token_address: Err("token_address was not initialized".to_string()),
            }
        }
        pub fn chain<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::ChainSymbol>,
        {
            self.chain = value
                .try_into()
                .map_err(|_| "conversion to `ChainSymbol` for chain failed".to_string());
            self
        }
        pub fn token_address<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.token_address = value
                .try_into()
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for token_address failed"
                        .to_string()
                });
            self
        }
        ///Sends a `GET` request to `/v1/token/{chain}/{tokenAddress}/marketData`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::TokenMarketData>, Error<()>> {
            let Self { client, chain, token_address } = self;
            let chain = chain.map_err(Error::InvalidRequest)?;
            let token_address = token_address.map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v1/token/{}/{}/marketData", client.baseurl, encode_path(& chain
                .to_string()), encode_path(& token_address.to_string()),
            );
            let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
            header_map
                .append(
                    ::reqwest::header::HeaderName::from_static("api-version"),
                    ::reqwest::header::HeaderValue::from_static(
                        super::Client::api_version(),
                    ),
                );
            #[allow(unused_mut)]
            let mut request = client
                .client
                .get(url)
                .header(
                    ::reqwest::header::ACCEPT,
                    ::reqwest::header::HeaderValue::from_static("application/json"),
                )
                .headers(header_map)
                .build()?;
            let info = OperationInfo {
                operation_id: "get_market_data",
            };
            client.pre(&mut request, &info).await?;
            let result = client.exec(request, &info).await;
            client.post(&result, &info).await?;
            let response = result?;
            match response.status().as_u16() {
                200u16 => ResponseValue::from_response::<()>(response).await,
                _ => Err(Error::UnexpectedResponse(response)),
            }
        }
    }
    /**Builder for [`Client::get_metadata`]

[`Client::get_metadata`]: super::Client::get_metadata*/
    #[derive(Debug, Clone)]
    pub struct GetMetadata<'a> {
        client: &'a super::Client,
        chain: Result<types::ChainSymbol, String>,
        token_address: Result<::std::string::String, String>,
    }
    impl<'a> GetMetadata<'a> {
        pub fn new(client: &'a super::Client) -> Self {
            Self {
                client: client,
                chain: Err("chain was not initialized".to_string()),
                token_address: Err("token_address was not initialized".to_string()),
            }
        }
        pub fn chain<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::ChainSymbol>,
        {
            self.chain = value
                .try_into()
                .map_err(|_| "conversion to `ChainSymbol` for chain failed".to_string());
            self
        }
        pub fn token_address<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.token_address = value
                .try_into()
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for token_address failed"
                        .to_string()
                });
            self
        }
        ///Sends a `GET` request to `/v1/token/{chain}/{tokenAddress}/metadata`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::TokenMetadata>, Error<()>> {
            let Self { client, chain, token_address } = self;
            let chain = chain.map_err(Error::InvalidRequest)?;
            let token_address = token_address.map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v1/token/{}/{}/metadata", client.baseurl, encode_path(& chain
                .to_string()), encode_path(& token_address.to_string()),
            );
            let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
            header_map
                .append(
                    ::reqwest::header::HeaderName::from_static("api-version"),
                    ::reqwest::header::HeaderValue::from_static(
                        super::Client::api_version(),
                    ),
                );
            #[allow(unused_mut)]
            let mut request = client
                .client
                .get(url)
                .header(
                    ::reqwest::header::ACCEPT,
                    ::reqwest::header::HeaderValue::from_static("application/json"),
                )
                .headers(header_map)
                .build()?;
            let info = OperationInfo {
                operation_id: "get_metadata",
            };
            client.pre(&mut request, &info).await?;
            let result = client.exec(request, &info).await;
            client.post(&result, &info).await?;
            let response = result?;
            match response.status().as_u16() {
                200u16 => ResponseValue::from_response::<()>(response).await,
                _ => Err(Error::UnexpectedResponse(response)),
            }
        }
    }
    /**Builder for [`Client::get_mint_and_burn`]

[`Client::get_mint_and_burn`]: super::Client::get_mint_and_burn*/
    #[derive(Debug, Clone)]
    pub struct GetMintAndBurn<'a> {
        client: &'a super::Client,
        chain: Result<types::ChainSymbol, String>,
        token_address: Result<::std::string::String, String>,
        cursor: Result<Option<::std::string::String>, String>,
        direction: Result<Option<types::GetMintAndBurnDirection>, String>,
        limit: Result<Option<::std::num::NonZeroU64>, String>,
        type_: Result<Option<types::GetMintAndBurnType>, String>,
    }
    impl<'a> GetMintAndBurn<'a> {
        pub fn new(client: &'a super::Client) -> Self {
            Self {
                client: client,
                chain: Err("chain was not initialized".to_string()),
                token_address: Err("token_address was not initialized".to_string()),
                cursor: Ok(None),
                direction: Ok(None),
                limit: Ok(None),
                type_: Ok(None),
            }
        }
        pub fn chain<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::ChainSymbol>,
        {
            self.chain = value
                .try_into()
                .map_err(|_| "conversion to `ChainSymbol` for chain failed".to_string());
            self
        }
        pub fn token_address<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.token_address = value
                .try_into()
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for token_address failed"
                        .to_string()
                });
            self
        }
        pub fn cursor<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.cursor = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for cursor failed"
                        .to_string()
                });
            self
        }
        pub fn direction<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::GetMintAndBurnDirection>,
        {
            self.direction = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `GetMintAndBurnDirection` for direction failed"
                        .to_string()
                });
            self
        }
        pub fn limit<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::num::NonZeroU64>,
        {
            self.limit = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: num :: NonZeroU64` for limit failed"
                        .to_string()
                });
            self
        }
        pub fn type_<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::GetMintAndBurnType>,
        {
            self.type_ = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `GetMintAndBurnType` for type_ failed".to_string()
                });
            self
        }
        ///Sends a `GET` request to `/v1/token/{chain}/{tokenAddress}/mintAndBurn`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::TokenCreationPage>, Error<()>> {
            let Self { client, chain, token_address, cursor, direction, limit, type_ } = self;
            let chain = chain.map_err(Error::InvalidRequest)?;
            let token_address = token_address.map_err(Error::InvalidRequest)?;
            let cursor = cursor.map_err(Error::InvalidRequest)?;
            let direction = direction.map_err(Error::InvalidRequest)?;
            let limit = limit.map_err(Error::InvalidRequest)?;
            let type_ = type_.map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v1/token/{}/{}/mintAndBurn", client.baseurl, encode_path(& chain
                .to_string()), encode_path(& token_address.to_string()),
            );
            let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
            header_map
                .append(
                    ::reqwest::header::HeaderName::from_static("api-version"),
                    ::reqwest::header::HeaderValue::from_static(
                        super::Client::api_version(),
                    ),
                );
            #[allow(unused_mut)]
            let mut request = client
                .client
                .get(url)
                .header(
                    ::reqwest::header::ACCEPT,
                    ::reqwest::header::HeaderValue::from_static("application/json"),
                )
                .query(&progenitor_middleware_client::QueryParam::new("cursor", &cursor))
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "direction",
                        &direction,
                    ),
                )
                .query(&progenitor_middleware_client::QueryParam::new("limit", &limit))
                .query(&progenitor_middleware_client::QueryParam::new("type", &type_))
                .headers(header_map)
                .build()?;
            let info = OperationInfo {
                operation_id: "get_mint_and_burn",
            };
            client.pre(&mut request, &info).await?;
            let result = client.exec(request, &info).await;
            client.post(&result, &info).await?;
            let response = result?;
            match response.status().as_u16() {
                200u16 => ResponseValue::from_response::<()>(response).await,
                _ => Err(Error::UnexpectedResponse(response)),
            }
        }
    }
    /**Builder for [`Client::get_pools`]

[`Client::get_pools`]: super::Client::get_pools*/
    #[derive(Debug, Clone)]
    pub struct GetPools<'a> {
        client: &'a super::Client,
        chain: Result<types::ChainSymbol, String>,
        token_address: Result<::std::string::String, String>,
        cursor: Result<Option<::std::string::String>, String>,
        direction: Result<Option<types::GetPoolsDirection>, String>,
        limit: Result<Option<::std::num::NonZeroU64>, String>,
        max_tvl_in_sol: Result<Option<::std::string::String>, String>,
        max_tvl_in_usd: Result<Option<::std::string::String>, String>,
        min_tvl_in_sol: Result<Option<::std::string::String>, String>,
        min_tvl_in_usd: Result<Option<::std::string::String>, String>,
        sort_by: Result<Option<types::GetPoolsSortBy>, String>,
        sort_direction: Result<Option<types::GetPoolsSortDirection>, String>,
    }
    impl<'a> GetPools<'a> {
        pub fn new(client: &'a super::Client) -> Self {
            Self {
                client: client,
                chain: Err("chain was not initialized".to_string()),
                token_address: Err("token_address was not initialized".to_string()),
                cursor: Ok(None),
                direction: Ok(None),
                limit: Ok(None),
                max_tvl_in_sol: Ok(None),
                max_tvl_in_usd: Ok(None),
                min_tvl_in_sol: Ok(None),
                min_tvl_in_usd: Ok(None),
                sort_by: Ok(None),
                sort_direction: Ok(None),
            }
        }
        pub fn chain<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::ChainSymbol>,
        {
            self.chain = value
                .try_into()
                .map_err(|_| "conversion to `ChainSymbol` for chain failed".to_string());
            self
        }
        pub fn token_address<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.token_address = value
                .try_into()
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for token_address failed"
                        .to_string()
                });
            self
        }
        pub fn cursor<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.cursor = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for cursor failed"
                        .to_string()
                });
            self
        }
        pub fn direction<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::GetPoolsDirection>,
        {
            self.direction = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `GetPoolsDirection` for direction failed".to_string()
                });
            self
        }
        pub fn limit<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::num::NonZeroU64>,
        {
            self.limit = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: num :: NonZeroU64` for limit failed"
                        .to_string()
                });
            self
        }
        pub fn max_tvl_in_sol<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.max_tvl_in_sol = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for max_tvl_in_sol failed"
                        .to_string()
                });
            self
        }
        pub fn max_tvl_in_usd<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.max_tvl_in_usd = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for max_tvl_in_usd failed"
                        .to_string()
                });
            self
        }
        pub fn min_tvl_in_sol<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.min_tvl_in_sol = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for min_tvl_in_sol failed"
                        .to_string()
                });
            self
        }
        pub fn min_tvl_in_usd<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.min_tvl_in_usd = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for min_tvl_in_usd failed"
                        .to_string()
                });
            self
        }
        pub fn sort_by<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::GetPoolsSortBy>,
        {
            self.sort_by = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `GetPoolsSortBy` for sort_by failed".to_string()
                });
            self
        }
        pub fn sort_direction<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::GetPoolsSortDirection>,
        {
            self.sort_direction = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `GetPoolsSortDirection` for sort_direction failed"
                        .to_string()
                });
            self
        }
        ///Sends a `GET` request to `/v1/token/{chain}/{tokenAddress}/pools`
        pub async fn send(self) -> Result<ResponseValue<types::DexPoolPage>, Error<()>> {
            let Self {
                client,
                chain,
                token_address,
                cursor,
                direction,
                limit,
                max_tvl_in_sol,
                max_tvl_in_usd,
                min_tvl_in_sol,
                min_tvl_in_usd,
                sort_by,
                sort_direction,
            } = self;
            let chain = chain.map_err(Error::InvalidRequest)?;
            let token_address = token_address.map_err(Error::InvalidRequest)?;
            let cursor = cursor.map_err(Error::InvalidRequest)?;
            let direction = direction.map_err(Error::InvalidRequest)?;
            let limit = limit.map_err(Error::InvalidRequest)?;
            let max_tvl_in_sol = max_tvl_in_sol.map_err(Error::InvalidRequest)?;
            let max_tvl_in_usd = max_tvl_in_usd.map_err(Error::InvalidRequest)?;
            let min_tvl_in_sol = min_tvl_in_sol.map_err(Error::InvalidRequest)?;
            let min_tvl_in_usd = min_tvl_in_usd.map_err(Error::InvalidRequest)?;
            let sort_by = sort_by.map_err(Error::InvalidRequest)?;
            let sort_direction = sort_direction.map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v1/token/{}/{}/pools", client.baseurl, encode_path(& chain
                .to_string()), encode_path(& token_address.to_string()),
            );
            let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
            header_map
                .append(
                    ::reqwest::header::HeaderName::from_static("api-version"),
                    ::reqwest::header::HeaderValue::from_static(
                        super::Client::api_version(),
                    ),
                );
            #[allow(unused_mut)]
            let mut request = client
                .client
                .get(url)
                .header(
                    ::reqwest::header::ACCEPT,
                    ::reqwest::header::HeaderValue::from_static("application/json"),
                )
                .query(&progenitor_middleware_client::QueryParam::new("cursor", &cursor))
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "direction",
                        &direction,
                    ),
                )
                .query(&progenitor_middleware_client::QueryParam::new("limit", &limit))
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "maxTvlInSol",
                        &max_tvl_in_sol,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "maxTvlInUsd",
                        &max_tvl_in_usd,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "minTvlInSol",
                        &min_tvl_in_sol,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "minTvlInUsd",
                        &min_tvl_in_usd,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new("sortBy", &sort_by),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "sortDirection",
                        &sort_direction,
                    ),
                )
                .headers(header_map)
                .build()?;
            let info = OperationInfo {
                operation_id: "get_pools",
            };
            client.pre(&mut request, &info).await?;
            let result = client.exec(request, &info).await;
            client.post(&result, &info).await?;
            let response = result?;
            match response.status().as_u16() {
                200u16 => ResponseValue::from_response::<()>(response).await,
                _ => Err(Error::UnexpectedResponse(response)),
            }
        }
    }
    /**Builder for [`Client::get_price_by_time`]

[`Client::get_price_by_time`]: super::Client::get_price_by_time*/
    #[derive(Debug, Clone)]
    pub struct GetPriceByTime<'a> {
        client: &'a super::Client,
        chain: Result<types::ChainSymbol, String>,
        token_address: Result<::std::string::String, String>,
        timestamp: Result<i64, String>,
    }
    impl<'a> GetPriceByTime<'a> {
        pub fn new(client: &'a super::Client) -> Self {
            Self {
                client: client,
                chain: Err("chain was not initialized".to_string()),
                token_address: Err("token_address was not initialized".to_string()),
                timestamp: Err("timestamp was not initialized".to_string()),
            }
        }
        pub fn chain<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::ChainSymbol>,
        {
            self.chain = value
                .try_into()
                .map_err(|_| "conversion to `ChainSymbol` for chain failed".to_string());
            self
        }
        pub fn token_address<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.token_address = value
                .try_into()
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for token_address failed"
                        .to_string()
                });
            self
        }
        pub fn timestamp<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<i64>,
        {
            self.timestamp = value
                .try_into()
                .map_err(|_| "conversion to `i64` for timestamp failed".to_string());
            self
        }
        ///Sends a `GET` request to `/v1/token/{chain}/{tokenAddress}/price`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::TokenPriceDto>, Error<()>> {
            let Self { client, chain, token_address, timestamp } = self;
            let chain = chain.map_err(Error::InvalidRequest)?;
            let token_address = token_address.map_err(Error::InvalidRequest)?;
            let timestamp = timestamp.map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v1/token/{}/{}/price", client.baseurl, encode_path(& chain
                .to_string()), encode_path(& token_address.to_string()),
            );
            let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
            header_map
                .append(
                    ::reqwest::header::HeaderName::from_static("api-version"),
                    ::reqwest::header::HeaderValue::from_static(
                        super::Client::api_version(),
                    ),
                );
            #[allow(unused_mut)]
            let mut request = client
                .client
                .get(url)
                .header(
                    ::reqwest::header::ACCEPT,
                    ::reqwest::header::HeaderValue::from_static("application/json"),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "timestamp",
                        &timestamp,
                    ),
                )
                .headers(header_map)
                .build()?;
            let info = OperationInfo {
                operation_id: "get_price_by_time",
            };
            client.pre(&mut request, &info).await?;
            let result = client.exec(request, &info).await;
            client.post(&result, &info).await?;
            let response = result?;
            match response.status().as_u16() {
                200u16 => ResponseValue::from_response::<()>(response).await,
                _ => Err(Error::UnexpectedResponse(response)),
            }
        }
    }
    /**Builder for [`Client::get_prices`]

[`Client::get_prices`]: super::Client::get_prices*/
    #[derive(Debug, Clone)]
    pub struct GetPrices<'a> {
        client: &'a super::Client,
        chain: Result<types::ChainSymbol, String>,
        token_address: Result<::std::string::String, String>,
        cursor: Result<Option<::std::string::String>, String>,
        direction: Result<Option<types::GetPricesDirection>, String>,
        limit: Result<Option<::std::num::NonZeroU64>, String>,
    }
    impl<'a> GetPrices<'a> {
        pub fn new(client: &'a super::Client) -> Self {
            Self {
                client: client,
                chain: Err("chain was not initialized".to_string()),
                token_address: Err("token_address was not initialized".to_string()),
                cursor: Ok(None),
                direction: Ok(None),
                limit: Ok(None),
            }
        }
        pub fn chain<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::ChainSymbol>,
        {
            self.chain = value
                .try_into()
                .map_err(|_| "conversion to `ChainSymbol` for chain failed".to_string());
            self
        }
        pub fn token_address<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.token_address = value
                .try_into()
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for token_address failed"
                        .to_string()
                });
            self
        }
        pub fn cursor<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.cursor = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for cursor failed"
                        .to_string()
                });
            self
        }
        pub fn direction<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::GetPricesDirection>,
        {
            self.direction = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `GetPricesDirection` for direction failed".to_string()
                });
            self
        }
        pub fn limit<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::num::NonZeroU64>,
        {
            self.limit = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: num :: NonZeroU64` for limit failed"
                        .to_string()
                });
            self
        }
        ///Sends a `GET` request to `/v1/token/{chain}/{tokenAddress}/prices`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::TokenPricePage>, Error<()>> {
            let Self { client, chain, token_address, cursor, direction, limit } = self;
            let chain = chain.map_err(Error::InvalidRequest)?;
            let token_address = token_address.map_err(Error::InvalidRequest)?;
            let cursor = cursor.map_err(Error::InvalidRequest)?;
            let direction = direction.map_err(Error::InvalidRequest)?;
            let limit = limit.map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v1/token/{}/{}/prices", client.baseurl, encode_path(& chain
                .to_string()), encode_path(& token_address.to_string()),
            );
            let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
            header_map
                .append(
                    ::reqwest::header::HeaderName::from_static("api-version"),
                    ::reqwest::header::HeaderValue::from_static(
                        super::Client::api_version(),
                    ),
                );
            #[allow(unused_mut)]
            let mut request = client
                .client
                .get(url)
                .header(
                    ::reqwest::header::ACCEPT,
                    ::reqwest::header::HeaderValue::from_static("application/json"),
                )
                .query(&progenitor_middleware_client::QueryParam::new("cursor", &cursor))
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "direction",
                        &direction,
                    ),
                )
                .query(&progenitor_middleware_client::QueryParam::new("limit", &limit))
                .headers(header_map)
                .build()?;
            let info = OperationInfo {
                operation_id: "get_prices",
            };
            client.pre(&mut request, &info).await?;
            let result = client.exec(request, &info).await;
            client.post(&result, &info).await?;
            let response = result?;
            match response.status().as_u16() {
                200u16 => ResponseValue::from_response::<()>(response).await,
                _ => Err(Error::UnexpectedResponse(response)),
            }
        }
    }
    /**Builder for [`Client::get_security`]

[`Client::get_security`]: super::Client::get_security*/
    #[derive(Debug, Clone)]
    pub struct GetSecurity<'a> {
        client: &'a super::Client,
        chain: Result<types::ChainSymbol, String>,
        token_address: Result<::std::string::String, String>,
    }
    impl<'a> GetSecurity<'a> {
        pub fn new(client: &'a super::Client) -> Self {
            Self {
                client: client,
                chain: Err("chain was not initialized".to_string()),
                token_address: Err("token_address was not initialized".to_string()),
            }
        }
        pub fn chain<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::ChainSymbol>,
        {
            self.chain = value
                .try_into()
                .map_err(|_| "conversion to `ChainSymbol` for chain failed".to_string());
            self
        }
        pub fn token_address<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.token_address = value
                .try_into()
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for token_address failed"
                        .to_string()
                });
            self
        }
        ///Sends a `GET` request to `/v1/token/{chain}/{tokenAddress}/security`
        pub async fn send(
            self,
        ) -> Result<
            ResponseValue<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
            Error<()>,
        > {
            let Self { client, chain, token_address } = self;
            let chain = chain.map_err(Error::InvalidRequest)?;
            let token_address = token_address.map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v1/token/{}/{}/security", client.baseurl, encode_path(& chain
                .to_string()), encode_path(& token_address.to_string()),
            );
            let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
            header_map
                .append(
                    ::reqwest::header::HeaderName::from_static("api-version"),
                    ::reqwest::header::HeaderValue::from_static(
                        super::Client::api_version(),
                    ),
                );
            #[allow(unused_mut)]
            let mut request = client
                .client
                .get(url)
                .header(
                    ::reqwest::header::ACCEPT,
                    ::reqwest::header::HeaderValue::from_static("application/json"),
                )
                .headers(header_map)
                .build()?;
            let info = OperationInfo {
                operation_id: "get_security",
            };
            client.pre(&mut request, &info).await?;
            let result = client.exec(request, &info).await;
            client.post(&result, &info).await?;
            let response = result?;
            match response.status().as_u16() {
                200u16 => ResponseValue::from_response::<()>(response).await,
                _ => Err(Error::UnexpectedResponse(response)),
            }
        }
    }
    /**Builder for [`Client::get_stats`]

[`Client::get_stats`]: super::Client::get_stats*/
    #[derive(Debug, Clone)]
    pub struct GetStats<'a> {
        client: &'a super::Client,
        chain: Result<types::ChainSymbol, String>,
        token_address: Result<::std::string::String, String>,
    }
    impl<'a> GetStats<'a> {
        pub fn new(client: &'a super::Client) -> Self {
            Self {
                client: client,
                chain: Err("chain was not initialized".to_string()),
                token_address: Err("token_address was not initialized".to_string()),
            }
        }
        pub fn chain<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::ChainSymbol>,
        {
            self.chain = value
                .try_into()
                .map_err(|_| "conversion to `ChainSymbol` for chain failed".to_string());
            self
        }
        pub fn token_address<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.token_address = value
                .try_into()
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for token_address failed"
                        .to_string()
                });
            self
        }
        ///Sends a `GET` request to `/v1/token/{chain}/{tokenAddress}/stats`
        pub async fn send(self) -> Result<ResponseValue<types::TokenStat>, Error<()>> {
            let Self { client, chain, token_address } = self;
            let chain = chain.map_err(Error::InvalidRequest)?;
            let token_address = token_address.map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v1/token/{}/{}/stats", client.baseurl, encode_path(& chain
                .to_string()), encode_path(& token_address.to_string()),
            );
            let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
            header_map
                .append(
                    ::reqwest::header::HeaderName::from_static("api-version"),
                    ::reqwest::header::HeaderValue::from_static(
                        super::Client::api_version(),
                    ),
                );
            #[allow(unused_mut)]
            let mut request = client
                .client
                .get(url)
                .header(
                    ::reqwest::header::ACCEPT,
                    ::reqwest::header::HeaderValue::from_static("application/json"),
                )
                .headers(header_map)
                .build()?;
            let info = OperationInfo {
                operation_id: "get_stats",
            };
            client.pre(&mut request, &info).await?;
            let result = client.exec(request, &info).await;
            client.post(&result, &info).await?;
            let response = result?;
            match response.status().as_u16() {
                200u16 => ResponseValue::from_response::<()>(response).await,
                _ => Err(Error::UnexpectedResponse(response)),
            }
        }
    }
    /**Builder for [`Client::get_top_holders`]

[`Client::get_top_holders`]: super::Client::get_top_holders*/
    #[derive(Debug, Clone)]
    pub struct GetTopHolders<'a> {
        client: &'a super::Client,
        chain: Result<types::ChainSymbol, String>,
        token_address: Result<::std::string::String, String>,
    }
    impl<'a> GetTopHolders<'a> {
        pub fn new(client: &'a super::Client) -> Self {
            Self {
                client: client,
                chain: Err("chain was not initialized".to_string()),
                token_address: Err("token_address was not initialized".to_string()),
            }
        }
        pub fn chain<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::ChainSymbol>,
        {
            self.chain = value
                .try_into()
                .map_err(|_| "conversion to `ChainSymbol` for chain failed".to_string());
            self
        }
        pub fn token_address<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.token_address = value
                .try_into()
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for token_address failed"
                        .to_string()
                });
            self
        }
        ///Sends a `GET` request to `/v1/token/{chain}/{tokenAddress}/topHolders`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::TokenHolderPage>, Error<()>> {
            let Self { client, chain, token_address } = self;
            let chain = chain.map_err(Error::InvalidRequest)?;
            let token_address = token_address.map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v1/token/{}/{}/topHolders", client.baseurl, encode_path(& chain
                .to_string()), encode_path(& token_address.to_string()),
            );
            let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
            header_map
                .append(
                    ::reqwest::header::HeaderName::from_static("api-version"),
                    ::reqwest::header::HeaderValue::from_static(
                        super::Client::api_version(),
                    ),
                );
            #[allow(unused_mut)]
            let mut request = client
                .client
                .get(url)
                .header(
                    ::reqwest::header::ACCEPT,
                    ::reqwest::header::HeaderValue::from_static("application/json"),
                )
                .headers(header_map)
                .build()?;
            let info = OperationInfo {
                operation_id: "get_top_holders",
            };
            client.pre(&mut request, &info).await?;
            let result = client.exec(request, &info).await;
            client.post(&result, &info).await?;
            let response = result?;
            match response.status().as_u16() {
                200u16 => ResponseValue::from_response::<()>(response).await,
                _ => Err(Error::UnexpectedResponse(response)),
            }
        }
    }
    /**Builder for [`Client::get_token_traders`]

[`Client::get_token_traders`]: super::Client::get_token_traders*/
    #[derive(Debug, Clone)]
    pub struct GetTokenTraders<'a> {
        client: &'a super::Client,
        chain: Result<types::ChainSymbol, String>,
        token_address: Result<::std::string::String, String>,
        tag: Result<types::TokenTraderTag, String>,
    }
    impl<'a> GetTokenTraders<'a> {
        pub fn new(client: &'a super::Client) -> Self {
            Self {
                client: client,
                chain: Err("chain was not initialized".to_string()),
                token_address: Err("token_address was not initialized".to_string()),
                tag: Err("tag was not initialized".to_string()),
            }
        }
        pub fn chain<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::ChainSymbol>,
        {
            self.chain = value
                .try_into()
                .map_err(|_| "conversion to `ChainSymbol` for chain failed".to_string());
            self
        }
        pub fn token_address<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.token_address = value
                .try_into()
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for token_address failed"
                        .to_string()
                });
            self
        }
        pub fn tag<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::TokenTraderTag>,
        {
            self.tag = value
                .try_into()
                .map_err(|_| {
                    "conversion to `TokenTraderTag` for tag failed".to_string()
                });
            self
        }
        ///Sends a `GET` request to `/v1/token/{chain}/{tokenAddress}/traders/{tag}`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<::std::vec::Vec<types::TokenTrader>>, Error<()>> {
            let Self { client, chain, token_address, tag } = self;
            let chain = chain.map_err(Error::InvalidRequest)?;
            let token_address = token_address.map_err(Error::InvalidRequest)?;
            let tag = tag.map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v1/token/{}/{}/traders/{}", client.baseurl, encode_path(& chain
                .to_string()), encode_path(& token_address.to_string()), encode_path(&
                tag.to_string()),
            );
            let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
            header_map
                .append(
                    ::reqwest::header::HeaderName::from_static("api-version"),
                    ::reqwest::header::HeaderValue::from_static(
                        super::Client::api_version(),
                    ),
                );
            #[allow(unused_mut)]
            let mut request = client
                .client
                .get(url)
                .header(
                    ::reqwest::header::ACCEPT,
                    ::reqwest::header::HeaderValue::from_static("application/json"),
                )
                .headers(header_map)
                .build()?;
            let info = OperationInfo {
                operation_id: "get_token_traders",
            };
            client.pre(&mut request, &info).await?;
            let result = client.exec(request, &info).await;
            client.post(&result, &info).await?;
            let response = result?;
            match response.status().as_u16() {
                200u16 => ResponseValue::from_response::<()>(response).await,
                _ => Err(Error::UnexpectedResponse(response)),
            }
        }
    }
    /**Builder for [`Client::get_token_transfer_total`]

[`Client::get_token_transfer_total`]: super::Client::get_token_transfer_total*/
    #[derive(Debug, Clone)]
    pub struct GetTokenTransferTotal<'a> {
        client: &'a super::Client,
        chain: Result<types::ChainSymbol, String>,
        token_address: Result<::std::string::String, String>,
        after_timestamp: Result<Option<i64>, String>,
        before_timestamp: Result<Option<i64>, String>,
        cursor: Result<Option<::std::string::String>, String>,
        direction: Result<Option<types::GetTokenTransferTotalDirection>, String>,
        limit: Result<Option<::std::num::NonZeroU64>, String>,
    }
    impl<'a> GetTokenTransferTotal<'a> {
        pub fn new(client: &'a super::Client) -> Self {
            Self {
                client: client,
                chain: Err("chain was not initialized".to_string()),
                token_address: Err("token_address was not initialized".to_string()),
                after_timestamp: Ok(None),
                before_timestamp: Ok(None),
                cursor: Ok(None),
                direction: Ok(None),
                limit: Ok(None),
            }
        }
        pub fn chain<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::ChainSymbol>,
        {
            self.chain = value
                .try_into()
                .map_err(|_| "conversion to `ChainSymbol` for chain failed".to_string());
            self
        }
        pub fn token_address<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.token_address = value
                .try_into()
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for token_address failed"
                        .to_string()
                });
            self
        }
        pub fn after_timestamp<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<i64>,
        {
            self.after_timestamp = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `i64` for after_timestamp failed".to_string()
                });
            self
        }
        pub fn before_timestamp<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<i64>,
        {
            self.before_timestamp = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `i64` for before_timestamp failed".to_string()
                });
            self
        }
        pub fn cursor<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.cursor = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for cursor failed"
                        .to_string()
                });
            self
        }
        pub fn direction<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::GetTokenTransferTotalDirection>,
        {
            self.direction = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `GetTokenTransferTotalDirection` for direction failed"
                        .to_string()
                });
            self
        }
        pub fn limit<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::num::NonZeroU64>,
        {
            self.limit = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: num :: NonZeroU64` for limit failed"
                        .to_string()
                });
            self
        }
        ///Sends a `GET` request to `/v1/token/{chain}/{tokenAddress}/transfer-total`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::TokenTransferTotalDto>, Error<()>> {
            let Self {
                client,
                chain,
                token_address,
                after_timestamp,
                before_timestamp,
                cursor,
                direction,
                limit,
            } = self;
            let chain = chain.map_err(Error::InvalidRequest)?;
            let token_address = token_address.map_err(Error::InvalidRequest)?;
            let after_timestamp = after_timestamp.map_err(Error::InvalidRequest)?;
            let before_timestamp = before_timestamp.map_err(Error::InvalidRequest)?;
            let cursor = cursor.map_err(Error::InvalidRequest)?;
            let direction = direction.map_err(Error::InvalidRequest)?;
            let limit = limit.map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v1/token/{}/{}/transfer-total", client.baseurl, encode_path(& chain
                .to_string()), encode_path(& token_address.to_string()),
            );
            let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
            header_map
                .append(
                    ::reqwest::header::HeaderName::from_static("api-version"),
                    ::reqwest::header::HeaderValue::from_static(
                        super::Client::api_version(),
                    ),
                );
            #[allow(unused_mut)]
            let mut request = client
                .client
                .get(url)
                .header(
                    ::reqwest::header::ACCEPT,
                    ::reqwest::header::HeaderValue::from_static("application/json"),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "afterTimestamp",
                        &after_timestamp,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "beforeTimestamp",
                        &before_timestamp,
                    ),
                )
                .query(&progenitor_middleware_client::QueryParam::new("cursor", &cursor))
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "direction",
                        &direction,
                    ),
                )
                .query(&progenitor_middleware_client::QueryParam::new("limit", &limit))
                .headers(header_map)
                .build()?;
            let info = OperationInfo {
                operation_id: "get_token_transfer_total",
            };
            client.pre(&mut request, &info).await?;
            let result = client.exec(request, &info).await;
            client.post(&result, &info).await?;
            let response = result?;
            match response.status().as_u16() {
                200u16 => ResponseValue::from_response::<()>(response).await,
                _ => Err(Error::UnexpectedResponse(response)),
            }
        }
    }
    /**Builder for [`Client::get_token_transfers`]

[`Client::get_token_transfers`]: super::Client::get_token_transfers*/
    #[derive(Debug, Clone)]
    pub struct GetTokenTransfers<'a> {
        client: &'a super::Client,
        chain: Result<types::ChainSymbol, String>,
        token_address: Result<::std::string::String, String>,
        after_timestamp: Result<Option<i64>, String>,
        before_timestamp: Result<Option<i64>, String>,
        cursor: Result<Option<::std::string::String>, String>,
        direction: Result<Option<types::GetTokenTransfersDirection>, String>,
        limit: Result<Option<::std::num::NonZeroU64>, String>,
    }
    impl<'a> GetTokenTransfers<'a> {
        pub fn new(client: &'a super::Client) -> Self {
            Self {
                client: client,
                chain: Err("chain was not initialized".to_string()),
                token_address: Err("token_address was not initialized".to_string()),
                after_timestamp: Ok(None),
                before_timestamp: Ok(None),
                cursor: Ok(None),
                direction: Ok(None),
                limit: Ok(None),
            }
        }
        pub fn chain<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::ChainSymbol>,
        {
            self.chain = value
                .try_into()
                .map_err(|_| "conversion to `ChainSymbol` for chain failed".to_string());
            self
        }
        pub fn token_address<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.token_address = value
                .try_into()
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for token_address failed"
                        .to_string()
                });
            self
        }
        pub fn after_timestamp<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<i64>,
        {
            self.after_timestamp = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `i64` for after_timestamp failed".to_string()
                });
            self
        }
        pub fn before_timestamp<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<i64>,
        {
            self.before_timestamp = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `i64` for before_timestamp failed".to_string()
                });
            self
        }
        pub fn cursor<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.cursor = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for cursor failed"
                        .to_string()
                });
            self
        }
        pub fn direction<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::GetTokenTransfersDirection>,
        {
            self.direction = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `GetTokenTransfersDirection` for direction failed"
                        .to_string()
                });
            self
        }
        pub fn limit<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::num::NonZeroU64>,
        {
            self.limit = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: num :: NonZeroU64` for limit failed"
                        .to_string()
                });
            self
        }
        ///Sends a `GET` request to `/v1/token/{chain}/{tokenAddress}/transfers`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::TokenTransferPage>, Error<()>> {
            let Self {
                client,
                chain,
                token_address,
                after_timestamp,
                before_timestamp,
                cursor,
                direction,
                limit,
            } = self;
            let chain = chain.map_err(Error::InvalidRequest)?;
            let token_address = token_address.map_err(Error::InvalidRequest)?;
            let after_timestamp = after_timestamp.map_err(Error::InvalidRequest)?;
            let before_timestamp = before_timestamp.map_err(Error::InvalidRequest)?;
            let cursor = cursor.map_err(Error::InvalidRequest)?;
            let direction = direction.map_err(Error::InvalidRequest)?;
            let limit = limit.map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v1/token/{}/{}/transfers", client.baseurl, encode_path(& chain
                .to_string()), encode_path(& token_address.to_string()),
            );
            let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
            header_map
                .append(
                    ::reqwest::header::HeaderName::from_static("api-version"),
                    ::reqwest::header::HeaderValue::from_static(
                        super::Client::api_version(),
                    ),
                );
            #[allow(unused_mut)]
            let mut request = client
                .client
                .get(url)
                .header(
                    ::reqwest::header::ACCEPT,
                    ::reqwest::header::HeaderValue::from_static("application/json"),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "afterTimestamp",
                        &after_timestamp,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "beforeTimestamp",
                        &before_timestamp,
                    ),
                )
                .query(&progenitor_middleware_client::QueryParam::new("cursor", &cursor))
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "direction",
                        &direction,
                    ),
                )
                .query(&progenitor_middleware_client::QueryParam::new("limit", &limit))
                .headers(header_map)
                .build()?;
            let info = OperationInfo {
                operation_id: "get_token_transfers",
            };
            client.pre(&mut request, &info).await?;
            let result = client.exec(request, &info).await;
            client.post(&result, &info).await?;
            let response = result?;
            match response.status().as_u16() {
                200u16 => ResponseValue::from_response::<()>(response).await,
                _ => Err(Error::UnexpectedResponse(response)),
            }
        }
    }
    /**Builder for [`Client::get_trades`]

[`Client::get_trades`]: super::Client::get_trades*/
    #[derive(Debug, Clone)]
    pub struct GetTrades<'a> {
        client: &'a super::Client,
        chain: Result<types::ChainSymbol, String>,
        after_block_height: Result<Option<i64>, String>,
        after_timestamp: Result<Option<i64>, String>,
        before_block_height: Result<Option<i64>, String>,
        before_timestamp: Result<Option<i64>, String>,
        cursor: Result<Option<::std::string::String>, String>,
        direction: Result<Option<types::GetTradesDirection>, String>,
        limit: Result<Option<::std::num::NonZeroU64>, String>,
        pool_address: Result<Option<::std::string::String>, String>,
        token_address: Result<Option<::std::string::String>, String>,
        transactions_signature: Result<Option<::std::string::String>, String>,
        type_: Result<Option<types::GetTradesType>, String>,
        wallet_address: Result<Option<::std::string::String>, String>,
    }
    impl<'a> GetTrades<'a> {
        pub fn new(client: &'a super::Client) -> Self {
            Self {
                client: client,
                chain: Err("chain was not initialized".to_string()),
                after_block_height: Ok(None),
                after_timestamp: Ok(None),
                before_block_height: Ok(None),
                before_timestamp: Ok(None),
                cursor: Ok(None),
                direction: Ok(None),
                limit: Ok(None),
                pool_address: Ok(None),
                token_address: Ok(None),
                transactions_signature: Ok(None),
                type_: Ok(None),
                wallet_address: Ok(None),
            }
        }
        pub fn chain<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::ChainSymbol>,
        {
            self.chain = value
                .try_into()
                .map_err(|_| "conversion to `ChainSymbol` for chain failed".to_string());
            self
        }
        pub fn after_block_height<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<i64>,
        {
            self.after_block_height = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `i64` for after_block_height failed".to_string()
                });
            self
        }
        pub fn after_timestamp<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<i64>,
        {
            self.after_timestamp = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `i64` for after_timestamp failed".to_string()
                });
            self
        }
        pub fn before_block_height<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<i64>,
        {
            self.before_block_height = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `i64` for before_block_height failed".to_string()
                });
            self
        }
        pub fn before_timestamp<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<i64>,
        {
            self.before_timestamp = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `i64` for before_timestamp failed".to_string()
                });
            self
        }
        pub fn cursor<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.cursor = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for cursor failed"
                        .to_string()
                });
            self
        }
        pub fn direction<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::GetTradesDirection>,
        {
            self.direction = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `GetTradesDirection` for direction failed".to_string()
                });
            self
        }
        pub fn limit<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::num::NonZeroU64>,
        {
            self.limit = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: num :: NonZeroU64` for limit failed"
                        .to_string()
                });
            self
        }
        pub fn pool_address<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.pool_address = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for pool_address failed"
                        .to_string()
                });
            self
        }
        pub fn token_address<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.token_address = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for token_address failed"
                        .to_string()
                });
            self
        }
        pub fn transactions_signature<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.transactions_signature = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for transactions_signature failed"
                        .to_string()
                });
            self
        }
        pub fn type_<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::GetTradesType>,
        {
            self.type_ = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `GetTradesType` for type_ failed".to_string()
                });
            self
        }
        pub fn wallet_address<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.wallet_address = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for wallet_address failed"
                        .to_string()
                });
            self
        }
        ///Sends a `GET` request to `/v1/trade/{chain}`
        pub async fn send(self) -> Result<ResponseValue<types::TradePage>, Error<()>> {
            let Self {
                client,
                chain,
                after_block_height,
                after_timestamp,
                before_block_height,
                before_timestamp,
                cursor,
                direction,
                limit,
                pool_address,
                token_address,
                transactions_signature,
                type_,
                wallet_address,
            } = self;
            let chain = chain.map_err(Error::InvalidRequest)?;
            let after_block_height = after_block_height.map_err(Error::InvalidRequest)?;
            let after_timestamp = after_timestamp.map_err(Error::InvalidRequest)?;
            let before_block_height = before_block_height
                .map_err(Error::InvalidRequest)?;
            let before_timestamp = before_timestamp.map_err(Error::InvalidRequest)?;
            let cursor = cursor.map_err(Error::InvalidRequest)?;
            let direction = direction.map_err(Error::InvalidRequest)?;
            let limit = limit.map_err(Error::InvalidRequest)?;
            let pool_address = pool_address.map_err(Error::InvalidRequest)?;
            let token_address = token_address.map_err(Error::InvalidRequest)?;
            let transactions_signature = transactions_signature
                .map_err(Error::InvalidRequest)?;
            let type_ = type_.map_err(Error::InvalidRequest)?;
            let wallet_address = wallet_address.map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v1/trade/{}", client.baseurl, encode_path(& chain.to_string()),
            );
            let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
            header_map
                .append(
                    ::reqwest::header::HeaderName::from_static("api-version"),
                    ::reqwest::header::HeaderValue::from_static(
                        super::Client::api_version(),
                    ),
                );
            #[allow(unused_mut)]
            let mut request = client
                .client
                .get(url)
                .header(
                    ::reqwest::header::ACCEPT,
                    ::reqwest::header::HeaderValue::from_static("application/json"),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "afterBlockHeight",
                        &after_block_height,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "afterTimestamp",
                        &after_timestamp,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "beforeBlockHeight",
                        &before_block_height,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "beforeTimestamp",
                        &before_timestamp,
                    ),
                )
                .query(&progenitor_middleware_client::QueryParam::new("cursor", &cursor))
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "direction",
                        &direction,
                    ),
                )
                .query(&progenitor_middleware_client::QueryParam::new("limit", &limit))
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "poolAddress",
                        &pool_address,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "tokenAddress",
                        &token_address,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "transactionsSignature",
                        &transactions_signature,
                    ),
                )
                .query(&progenitor_middleware_client::QueryParam::new("type", &type_))
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "walletAddress",
                        &wallet_address,
                    ),
                )
                .headers(header_map)
                .build()?;
            let info = OperationInfo {
                operation_id: "get_trades",
            };
            client.pre(&mut request, &info).await?;
            let result = client.exec(request, &info).await;
            client.post(&result, &info).await?;
            let response = result?;
            match response.status().as_u16() {
                200u16 => ResponseValue::from_response::<()>(response).await,
                _ => Err(Error::UnexpectedResponse(response)),
            }
        }
    }
    /**Builder for [`Client::get_activities`]

[`Client::get_activities`]: super::Client::get_activities*/
    #[derive(Debug, Clone)]
    pub struct GetActivities<'a> {
        client: &'a super::Client,
        chain: Result<types::ChainSymbol, String>,
        after_block_height: Result<Option<i64>, String>,
        after_timestamp: Result<Option<i64>, String>,
        before_block_height: Result<Option<i64>, String>,
        before_timestamp: Result<Option<i64>, String>,
        cursor: Result<Option<::std::string::String>, String>,
        direction: Result<Option<types::GetActivitiesDirection>, String>,
        limit: Result<Option<::std::num::NonZeroU64>, String>,
        pool_address: Result<Option<::std::string::String>, String>,
        token_address: Result<Option<::std::string::String>, String>,
        transactions_signature: Result<Option<::std::string::String>, String>,
        type_: Result<Option<types::GetActivitiesType>, String>,
        wallet_address: Result<Option<::std::string::String>, String>,
    }
    impl<'a> GetActivities<'a> {
        pub fn new(client: &'a super::Client) -> Self {
            Self {
                client: client,
                chain: Err("chain was not initialized".to_string()),
                after_block_height: Ok(None),
                after_timestamp: Ok(None),
                before_block_height: Ok(None),
                before_timestamp: Ok(None),
                cursor: Ok(None),
                direction: Ok(None),
                limit: Ok(None),
                pool_address: Ok(None),
                token_address: Ok(None),
                transactions_signature: Ok(None),
                type_: Ok(None),
                wallet_address: Ok(None),
            }
        }
        pub fn chain<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::ChainSymbol>,
        {
            self.chain = value
                .try_into()
                .map_err(|_| "conversion to `ChainSymbol` for chain failed".to_string());
            self
        }
        pub fn after_block_height<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<i64>,
        {
            self.after_block_height = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `i64` for after_block_height failed".to_string()
                });
            self
        }
        pub fn after_timestamp<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<i64>,
        {
            self.after_timestamp = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `i64` for after_timestamp failed".to_string()
                });
            self
        }
        pub fn before_block_height<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<i64>,
        {
            self.before_block_height = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `i64` for before_block_height failed".to_string()
                });
            self
        }
        pub fn before_timestamp<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<i64>,
        {
            self.before_timestamp = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `i64` for before_timestamp failed".to_string()
                });
            self
        }
        pub fn cursor<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.cursor = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for cursor failed"
                        .to_string()
                });
            self
        }
        pub fn direction<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::GetActivitiesDirection>,
        {
            self.direction = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `GetActivitiesDirection` for direction failed"
                        .to_string()
                });
            self
        }
        pub fn limit<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::num::NonZeroU64>,
        {
            self.limit = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: num :: NonZeroU64` for limit failed"
                        .to_string()
                });
            self
        }
        pub fn pool_address<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.pool_address = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for pool_address failed"
                        .to_string()
                });
            self
        }
        pub fn token_address<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.token_address = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for token_address failed"
                        .to_string()
                });
            self
        }
        pub fn transactions_signature<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.transactions_signature = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for transactions_signature failed"
                        .to_string()
                });
            self
        }
        pub fn type_<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::GetActivitiesType>,
        {
            self.type_ = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `GetActivitiesType` for type_ failed".to_string()
                });
            self
        }
        pub fn wallet_address<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.wallet_address = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for wallet_address failed"
                        .to_string()
                });
            self
        }
        ///Sends a `GET` request to `/v1/trade/{chain}/activities`
        pub async fn send(self) -> Result<ResponseValue<types::TradePage>, Error<()>> {
            let Self {
                client,
                chain,
                after_block_height,
                after_timestamp,
                before_block_height,
                before_timestamp,
                cursor,
                direction,
                limit,
                pool_address,
                token_address,
                transactions_signature,
                type_,
                wallet_address,
            } = self;
            let chain = chain.map_err(Error::InvalidRequest)?;
            let after_block_height = after_block_height.map_err(Error::InvalidRequest)?;
            let after_timestamp = after_timestamp.map_err(Error::InvalidRequest)?;
            let before_block_height = before_block_height
                .map_err(Error::InvalidRequest)?;
            let before_timestamp = before_timestamp.map_err(Error::InvalidRequest)?;
            let cursor = cursor.map_err(Error::InvalidRequest)?;
            let direction = direction.map_err(Error::InvalidRequest)?;
            let limit = limit.map_err(Error::InvalidRequest)?;
            let pool_address = pool_address.map_err(Error::InvalidRequest)?;
            let token_address = token_address.map_err(Error::InvalidRequest)?;
            let transactions_signature = transactions_signature
                .map_err(Error::InvalidRequest)?;
            let type_ = type_.map_err(Error::InvalidRequest)?;
            let wallet_address = wallet_address.map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v1/trade/{}/activities", client.baseurl, encode_path(& chain
                .to_string()),
            );
            let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
            header_map
                .append(
                    ::reqwest::header::HeaderName::from_static("api-version"),
                    ::reqwest::header::HeaderValue::from_static(
                        super::Client::api_version(),
                    ),
                );
            #[allow(unused_mut)]
            let mut request = client
                .client
                .get(url)
                .header(
                    ::reqwest::header::ACCEPT,
                    ::reqwest::header::HeaderValue::from_static("application/json"),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "afterBlockHeight",
                        &after_block_height,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "afterTimestamp",
                        &after_timestamp,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "beforeBlockHeight",
                        &before_block_height,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "beforeTimestamp",
                        &before_timestamp,
                    ),
                )
                .query(&progenitor_middleware_client::QueryParam::new("cursor", &cursor))
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "direction",
                        &direction,
                    ),
                )
                .query(&progenitor_middleware_client::QueryParam::new("limit", &limit))
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "poolAddress",
                        &pool_address,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "tokenAddress",
                        &token_address,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "transactionsSignature",
                        &transactions_signature,
                    ),
                )
                .query(&progenitor_middleware_client::QueryParam::new("type", &type_))
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "walletAddress",
                        &wallet_address,
                    ),
                )
                .headers(header_map)
                .build()?;
            let info = OperationInfo {
                operation_id: "get_activities",
            };
            client.pre(&mut request, &info).await?;
            let result = client.exec(request, &info).await;
            client.post(&result, &info).await?;
            let response = result?;
            match response.status().as_u16() {
                200u16 => ResponseValue::from_response::<()>(response).await,
                _ => Err(Error::UnexpectedResponse(response)),
            }
        }
    }
    /**Builder for [`Client::get_top_traders`]

[`Client::get_top_traders`]: super::Client::get_top_traders*/
    #[derive(Debug, Clone)]
    pub struct GetTopTraders<'a> {
        client: &'a super::Client,
        chain: Result<types::ChainSymbol, String>,
        cursor: Result<Option<::std::string::String>, String>,
        direction: Result<Option<types::GetTopTradersDirection>, String>,
        limit: Result<Option<::std::num::NonZeroU64>, String>,
        sort_by: Result<Option<types::GetTopTradersSortBy>, String>,
        sort_type: Result<Option<types::GetTopTradersSortType>, String>,
        time_frame: Result<Option<types::GetTopTradersTimeFrame>, String>,
        token_address: Result<::std::string::String, String>,
    }
    impl<'a> GetTopTraders<'a> {
        pub fn new(client: &'a super::Client) -> Self {
            Self {
                client: client,
                chain: Err("chain was not initialized".to_string()),
                cursor: Ok(None),
                direction: Ok(None),
                limit: Ok(None),
                sort_by: Ok(None),
                sort_type: Ok(None),
                time_frame: Ok(None),
                token_address: Err("token_address was not initialized".to_string()),
            }
        }
        pub fn chain<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::ChainSymbol>,
        {
            self.chain = value
                .try_into()
                .map_err(|_| "conversion to `ChainSymbol` for chain failed".to_string());
            self
        }
        pub fn cursor<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.cursor = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for cursor failed"
                        .to_string()
                });
            self
        }
        pub fn direction<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::GetTopTradersDirection>,
        {
            self.direction = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `GetTopTradersDirection` for direction failed"
                        .to_string()
                });
            self
        }
        pub fn limit<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::num::NonZeroU64>,
        {
            self.limit = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: num :: NonZeroU64` for limit failed"
                        .to_string()
                });
            self
        }
        pub fn sort_by<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::GetTopTradersSortBy>,
        {
            self.sort_by = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `GetTopTradersSortBy` for sort_by failed".to_string()
                });
            self
        }
        pub fn sort_type<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::GetTopTradersSortType>,
        {
            self.sort_type = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `GetTopTradersSortType` for sort_type failed"
                        .to_string()
                });
            self
        }
        pub fn time_frame<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::GetTopTradersTimeFrame>,
        {
            self.time_frame = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `GetTopTradersTimeFrame` for time_frame failed"
                        .to_string()
                });
            self
        }
        pub fn token_address<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.token_address = value
                .try_into()
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for token_address failed"
                        .to_string()
                });
            self
        }
        ///Sends a `GET` request to `/v1/trade/{chain}/top-traders`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::TopTradersPage>, Error<()>> {
            let Self {
                client,
                chain,
                cursor,
                direction,
                limit,
                sort_by,
                sort_type,
                time_frame,
                token_address,
            } = self;
            let chain = chain.map_err(Error::InvalidRequest)?;
            let cursor = cursor.map_err(Error::InvalidRequest)?;
            let direction = direction.map_err(Error::InvalidRequest)?;
            let limit = limit.map_err(Error::InvalidRequest)?;
            let sort_by = sort_by.map_err(Error::InvalidRequest)?;
            let sort_type = sort_type.map_err(Error::InvalidRequest)?;
            let time_frame = time_frame.map_err(Error::InvalidRequest)?;
            let token_address = token_address.map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v1/trade/{}/top-traders", client.baseurl, encode_path(& chain
                .to_string()),
            );
            let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
            header_map
                .append(
                    ::reqwest::header::HeaderName::from_static("api-version"),
                    ::reqwest::header::HeaderValue::from_static(
                        super::Client::api_version(),
                    ),
                );
            #[allow(unused_mut)]
            let mut request = client
                .client
                .get(url)
                .header(
                    ::reqwest::header::ACCEPT,
                    ::reqwest::header::HeaderValue::from_static("application/json"),
                )
                .query(&progenitor_middleware_client::QueryParam::new("cursor", &cursor))
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "direction",
                        &direction,
                    ),
                )
                .query(&progenitor_middleware_client::QueryParam::new("limit", &limit))
                .query(
                    &progenitor_middleware_client::QueryParam::new("sortBy", &sort_by),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "sortType",
                        &sort_type,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "timeFrame",
                        &time_frame,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "tokenAddress",
                        &token_address,
                    ),
                )
                .headers(header_map)
                .build()?;
            let info = OperationInfo {
                operation_id: "get_top_traders",
            };
            client.pre(&mut request, &info).await?;
            let result = client.exec(request, &info).await;
            client.post(&result, &info).await?;
            let response = result?;
            match response.status().as_u16() {
                200u16 => ResponseValue::from_response::<()>(response).await,
                _ => Err(Error::UnexpectedResponse(response)),
            }
        }
    }
    /**Builder for [`Client::get_trader_gainers_losers`]

[`Client::get_trader_gainers_losers`]: super::Client::get_trader_gainers_losers*/
    #[derive(Debug, Clone)]
    pub struct GetTraderGainersLosers<'a> {
        client: &'a super::Client,
        chain: Result<types::ChainSymbol, String>,
        cursor: Result<Option<::std::string::String>, String>,
        direction: Result<Option<types::GetTraderGainersLosersDirection>, String>,
        limit: Result<Option<::std::num::NonZeroU64>, String>,
        resolution: Result<Option<types::TraderPnlResolution>, String>,
        sort_type: Result<Option<types::GetTraderGainersLosersSortType>, String>,
    }
    impl<'a> GetTraderGainersLosers<'a> {
        pub fn new(client: &'a super::Client) -> Self {
            Self {
                client: client,
                chain: Err("chain was not initialized".to_string()),
                cursor: Ok(None),
                direction: Ok(None),
                limit: Ok(None),
                resolution: Ok(None),
                sort_type: Ok(None),
            }
        }
        pub fn chain<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::ChainSymbol>,
        {
            self.chain = value
                .try_into()
                .map_err(|_| "conversion to `ChainSymbol` for chain failed".to_string());
            self
        }
        pub fn cursor<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.cursor = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for cursor failed"
                        .to_string()
                });
            self
        }
        pub fn direction<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::GetTraderGainersLosersDirection>,
        {
            self.direction = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `GetTraderGainersLosersDirection` for direction failed"
                        .to_string()
                });
            self
        }
        pub fn limit<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::num::NonZeroU64>,
        {
            self.limit = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: num :: NonZeroU64` for limit failed"
                        .to_string()
                });
            self
        }
        pub fn resolution<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::TraderPnlResolution>,
        {
            self.resolution = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `TraderPnlResolution` for resolution failed"
                        .to_string()
                });
            self
        }
        pub fn sort_type<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::GetTraderGainersLosersSortType>,
        {
            self.sort_type = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `GetTraderGainersLosersSortType` for sort_type failed"
                        .to_string()
                });
            self
        }
        ///Sends a `GET` request to `/v1/trade/{chain}/trader-gainers-losers`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::TraderGainersLosersPage>, Error<()>> {
            let Self {
                client,
                chain,
                cursor,
                direction,
                limit,
                resolution,
                sort_type,
            } = self;
            let chain = chain.map_err(Error::InvalidRequest)?;
            let cursor = cursor.map_err(Error::InvalidRequest)?;
            let direction = direction.map_err(Error::InvalidRequest)?;
            let limit = limit.map_err(Error::InvalidRequest)?;
            let resolution = resolution.map_err(Error::InvalidRequest)?;
            let sort_type = sort_type.map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v1/trade/{}/trader-gainers-losers", client.baseurl, encode_path(&
                chain.to_string()),
            );
            let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
            header_map
                .append(
                    ::reqwest::header::HeaderName::from_static("api-version"),
                    ::reqwest::header::HeaderValue::from_static(
                        super::Client::api_version(),
                    ),
                );
            #[allow(unused_mut)]
            let mut request = client
                .client
                .get(url)
                .header(
                    ::reqwest::header::ACCEPT,
                    ::reqwest::header::HeaderValue::from_static("application/json"),
                )
                .query(&progenitor_middleware_client::QueryParam::new("cursor", &cursor))
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "direction",
                        &direction,
                    ),
                )
                .query(&progenitor_middleware_client::QueryParam::new("limit", &limit))
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "resolution",
                        &resolution,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "sortType",
                        &sort_type,
                    ),
                )
                .headers(header_map)
                .build()?;
            let info = OperationInfo {
                operation_id: "get_trader_gainers_losers",
            };
            client.pre(&mut request, &info).await?;
            let result = client.exec(request, &info).await;
            client.post(&result, &info).await?;
            let response = result?;
            match response.status().as_u16() {
                200u16 => ResponseValue::from_response::<()>(response).await,
                _ => Err(Error::UnexpectedResponse(response)),
            }
        }
    }
    /**Builder for [`Client::get_gas_limit`]

[`Client::get_gas_limit`]: super::Client::get_gas_limit*/
    #[derive(Debug, Clone)]
    pub struct GetGasLimit<'a> {
        client: &'a super::Client,
        chain: Result<types::GetGasLimitChain, String>,
        body: Result<types::builder::EstimateGasLimitInput, String>,
    }
    impl<'a> GetGasLimit<'a> {
        pub fn new(client: &'a super::Client) -> Self {
            Self {
                client: client,
                chain: Err("chain was not initialized".to_string()),
                body: Ok(::std::default::Default::default()),
            }
        }
        pub fn chain<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::GetGasLimitChain>,
        {
            self.chain = value
                .try_into()
                .map_err(|_| {
                    "conversion to `GetGasLimitChain` for chain failed".to_string()
                });
            self
        }
        pub fn body<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::EstimateGasLimitInput>,
            <V as std::convert::TryInto<
                types::EstimateGasLimitInput,
            >>::Error: std::fmt::Display,
        {
            self.body = value
                .try_into()
                .map(From::from)
                .map_err(|s| {
                    format!(
                        "conversion to `EstimateGasLimitInput` for body failed: {}", s
                    )
                });
            self
        }
        pub fn body_map<F>(mut self, f: F) -> Self
        where
            F: std::ops::FnOnce(
                types::builder::EstimateGasLimitInput,
            ) -> types::builder::EstimateGasLimitInput,
        {
            self.body = self.body.map(f);
            self
        }
        ///Sends a `POST` request to `/v1/transaction/{chain}/estimate-gas-limit`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::EstimateGasLimitResponse>, Error<()>> {
            let Self { client, chain, body } = self;
            let chain = chain.map_err(Error::InvalidRequest)?;
            let body = body
                .and_then(|v| {
                    types::EstimateGasLimitInput::try_from(v).map_err(|e| e.to_string())
                })
                .map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v1/transaction/{}/estimate-gas-limit", client.baseurl, encode_path(&
                chain.to_string()),
            );
            let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
            header_map
                .append(
                    ::reqwest::header::HeaderName::from_static("api-version"),
                    ::reqwest::header::HeaderValue::from_static(
                        super::Client::api_version(),
                    ),
                );
            #[allow(unused_mut)]
            let mut request = client
                .client
                .post(url)
                .header(
                    ::reqwest::header::ACCEPT,
                    ::reqwest::header::HeaderValue::from_static("application/json"),
                )
                .json(&body)
                .headers(header_map)
                .build()?;
            let info = OperationInfo {
                operation_id: "get_gas_limit",
            };
            client.pre(&mut request, &info).await?;
            let result = client.exec(request, &info).await;
            client.post(&result, &info).await?;
            let response = result?;
            match response.status().as_u16() {
                200u16 => ResponseValue::from_response::<()>(response).await,
                _ => Err(Error::UnexpectedResponse(response)),
            }
        }
    }
    /**Builder for [`Client::get_gas_price`]

[`Client::get_gas_price`]: super::Client::get_gas_price*/
    #[derive(Debug, Clone)]
    pub struct GetGasPrice<'a> {
        client: &'a super::Client,
        chain: Result<types::GetGasPriceChain, String>,
    }
    impl<'a> GetGasPrice<'a> {
        pub fn new(client: &'a super::Client) -> Self {
            Self {
                client: client,
                chain: Err("chain was not initialized".to_string()),
            }
        }
        pub fn chain<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::GetGasPriceChain>,
        {
            self.chain = value
                .try_into()
                .map_err(|_| {
                    "conversion to `GetGasPriceChain` for chain failed".to_string()
                });
            self
        }
        ///Sends a `GET` request to `/v1/transaction/{chain}/gas-price`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::GasPriceResponse>, Error<()>> {
            let Self { client, chain } = self;
            let chain = chain.map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v1/transaction/{}/gas-price", client.baseurl, encode_path(& chain
                .to_string()),
            );
            let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
            header_map
                .append(
                    ::reqwest::header::HeaderName::from_static("api-version"),
                    ::reqwest::header::HeaderValue::from_static(
                        super::Client::api_version(),
                    ),
                );
            #[allow(unused_mut)]
            let mut request = client
                .client
                .get(url)
                .header(
                    ::reqwest::header::ACCEPT,
                    ::reqwest::header::HeaderValue::from_static("application/json"),
                )
                .headers(header_map)
                .build()?;
            let info = OperationInfo {
                operation_id: "get_gas_price",
            };
            client.pre(&mut request, &info).await?;
            let result = client.exec(request, &info).await;
            client.post(&result, &info).await?;
            let response = result?;
            match response.status().as_u16() {
                200u16 => ResponseValue::from_response::<()>(response).await,
                _ => Err(Error::UnexpectedResponse(response)),
            }
        }
    }
    /**Builder for [`Client::send`]

[`Client::send`]: super::Client::send*/
    #[derive(Debug, Clone)]
    pub struct Send<'a> {
        client: &'a super::Client,
        chain: Result<::std::string::String, String>,
        body: Result<types::builder::SendTxInput, String>,
    }
    impl<'a> Send<'a> {
        pub fn new(client: &'a super::Client) -> Self {
            Self {
                client: client,
                chain: Err("chain was not initialized".to_string()),
                body: Ok(::std::default::Default::default()),
            }
        }
        pub fn chain<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.chain = value
                .try_into()
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for chain failed"
                        .to_string()
                });
            self
        }
        pub fn body<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::SendTxInput>,
            <V as std::convert::TryInto<types::SendTxInput>>::Error: std::fmt::Display,
        {
            self.body = value
                .try_into()
                .map(From::from)
                .map_err(|s| {
                    format!("conversion to `SendTxInput` for body failed: {}", s)
                });
            self
        }
        pub fn body_map<F>(mut self, f: F) -> Self
        where
            F: std::ops::FnOnce(
                types::builder::SendTxInput,
            ) -> types::builder::SendTxInput,
        {
            self.body = self.body.map(f);
            self
        }
        ///Sends a `POST` request to `/v1/transaction/{chain}/send`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::SendTxResponse>, Error<()>> {
            let Self { client, chain, body } = self;
            let chain = chain.map_err(Error::InvalidRequest)?;
            let body = body
                .and_then(|v| types::SendTxInput::try_from(v).map_err(|e| e.to_string()))
                .map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v1/transaction/{}/send", client.baseurl, encode_path(& chain
                .to_string()),
            );
            let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
            header_map
                .append(
                    ::reqwest::header::HeaderName::from_static("api-version"),
                    ::reqwest::header::HeaderValue::from_static(
                        super::Client::api_version(),
                    ),
                );
            #[allow(unused_mut)]
            let mut request = client
                .client
                .post(url)
                .header(
                    ::reqwest::header::ACCEPT,
                    ::reqwest::header::HeaderValue::from_static("application/json"),
                )
                .json(&body)
                .headers(header_map)
                .build()?;
            let info = OperationInfo {
                operation_id: "send",
            };
            client.pre(&mut request, &info).await?;
            let result = client.exec(request, &info).await;
            client.post(&result, &info).await?;
            let response = result?;
            match response.status().as_u16() {
                200u16 => ResponseValue::from_response::<()>(response).await,
                _ => Err(Error::UnexpectedResponse(response)),
            }
        }
    }
    /**Builder for [`Client::get_wallet_first_tx`]

[`Client::get_wallet_first_tx`]: super::Client::get_wallet_first_tx*/
    #[derive(Debug, Clone)]
    pub struct GetWalletFirstTx<'a> {
        client: &'a super::Client,
        chain: Result<types::ChainSymbol, String>,
        wallet_addresses: Result<::std::string::String, String>,
    }
    impl<'a> GetWalletFirstTx<'a> {
        pub fn new(client: &'a super::Client) -> Self {
            Self {
                client: client,
                chain: Err("chain was not initialized".to_string()),
                wallet_addresses: Err("wallet_addresses was not initialized".to_string()),
            }
        }
        pub fn chain<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::ChainSymbol>,
        {
            self.chain = value
                .try_into()
                .map_err(|_| "conversion to `ChainSymbol` for chain failed".to_string());
            self
        }
        pub fn wallet_addresses<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.wallet_addresses = value
                .try_into()
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for wallet_addresses failed"
                        .to_string()
                });
            self
        }
        ///Sends a `GET` request to `/v1/wallet/{chain}/first-tx`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::WalletFirstTxDto>, Error<()>> {
            let Self { client, chain, wallet_addresses } = self;
            let chain = chain.map_err(Error::InvalidRequest)?;
            let wallet_addresses = wallet_addresses.map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v1/wallet/{}/first-tx", client.baseurl, encode_path(& chain
                .to_string()),
            );
            let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
            header_map
                .append(
                    ::reqwest::header::HeaderName::from_static("api-version"),
                    ::reqwest::header::HeaderValue::from_static(
                        super::Client::api_version(),
                    ),
                );
            #[allow(unused_mut)]
            let mut request = client
                .client
                .get(url)
                .header(
                    ::reqwest::header::ACCEPT,
                    ::reqwest::header::HeaderValue::from_static("application/json"),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "walletAddresses",
                        &wallet_addresses,
                    ),
                )
                .headers(header_map)
                .build()?;
            let info = OperationInfo {
                operation_id: "get_wallet_first_tx",
            };
            client.pre(&mut request, &info).await?;
            let result = client.exec(request, &info).await;
            client.post(&result, &info).await?;
            let response = result?;
            match response.status().as_u16() {
                200u16 => ResponseValue::from_response::<()>(response).await,
                _ => Err(Error::UnexpectedResponse(response)),
            }
        }
    }
    /**Builder for [`Client::get_net_worth_summary`]

[`Client::get_net_worth_summary`]: super::Client::get_net_worth_summary*/
    #[derive(Debug, Clone)]
    pub struct GetNetWorthSummary<'a> {
        client: &'a super::Client,
        chain: Result<types::ChainSymbol, String>,
        wallet_addresses: Result<::std::string::String, String>,
    }
    impl<'a> GetNetWorthSummary<'a> {
        pub fn new(client: &'a super::Client) -> Self {
            Self {
                client: client,
                chain: Err("chain was not initialized".to_string()),
                wallet_addresses: Err("wallet_addresses was not initialized".to_string()),
            }
        }
        pub fn chain<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::ChainSymbol>,
        {
            self.chain = value
                .try_into()
                .map_err(|_| "conversion to `ChainSymbol` for chain failed".to_string());
            self
        }
        pub fn wallet_addresses<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.wallet_addresses = value
                .try_into()
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for wallet_addresses failed"
                        .to_string()
                });
            self
        }
        ///Sends a `GET` request to `/v1/wallet/{chain}/net-worth-summary`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::WalletNetWorthSummaryDto>, Error<()>> {
            let Self { client, chain, wallet_addresses } = self;
            let chain = chain.map_err(Error::InvalidRequest)?;
            let wallet_addresses = wallet_addresses.map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v1/wallet/{}/net-worth-summary", client.baseurl, encode_path(& chain
                .to_string()),
            );
            let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
            header_map
                .append(
                    ::reqwest::header::HeaderName::from_static("api-version"),
                    ::reqwest::header::HeaderValue::from_static(
                        super::Client::api_version(),
                    ),
                );
            #[allow(unused_mut)]
            let mut request = client
                .client
                .get(url)
                .header(
                    ::reqwest::header::ACCEPT,
                    ::reqwest::header::HeaderValue::from_static("application/json"),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "walletAddresses",
                        &wallet_addresses,
                    ),
                )
                .headers(header_map)
                .build()?;
            let info = OperationInfo {
                operation_id: "get_net_worth_summary",
            };
            client.pre(&mut request, &info).await?;
            let result = client.exec(request, &info).await;
            client.post(&result, &info).await?;
            let response = result?;
            match response.status().as_u16() {
                200u16 => ResponseValue::from_response::<()>(response).await,
                _ => Err(Error::UnexpectedResponse(response)),
            }
        }
    }
    /**Builder for [`Client::get_pnl_by_wallet`]

[`Client::get_pnl_by_wallet`]: super::Client::get_pnl_by_wallet*/
    #[derive(Debug, Clone)]
    pub struct GetPnlByWallet<'a> {
        client: &'a super::Client,
        chain: Result<types::ChainSymbol, String>,
        cursor: Result<Option<::std::string::String>, String>,
        direction: Result<Option<types::GetPnlByWalletDirection>, String>,
        limit: Result<Option<::std::num::NonZeroU64>, String>,
        token_address: Result<::std::string::String, String>,
        wallet_addresses: Result<::std::string::String, String>,
    }
    impl<'a> GetPnlByWallet<'a> {
        pub fn new(client: &'a super::Client) -> Self {
            Self {
                client: client,
                chain: Err("chain was not initialized".to_string()),
                cursor: Ok(None),
                direction: Ok(None),
                limit: Ok(None),
                token_address: Err("token_address was not initialized".to_string()),
                wallet_addresses: Err("wallet_addresses was not initialized".to_string()),
            }
        }
        pub fn chain<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::ChainSymbol>,
        {
            self.chain = value
                .try_into()
                .map_err(|_| "conversion to `ChainSymbol` for chain failed".to_string());
            self
        }
        pub fn cursor<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.cursor = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for cursor failed"
                        .to_string()
                });
            self
        }
        pub fn direction<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::GetPnlByWalletDirection>,
        {
            self.direction = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `GetPnlByWalletDirection` for direction failed"
                        .to_string()
                });
            self
        }
        pub fn limit<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::num::NonZeroU64>,
        {
            self.limit = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: num :: NonZeroU64` for limit failed"
                        .to_string()
                });
            self
        }
        pub fn token_address<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.token_address = value
                .try_into()
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for token_address failed"
                        .to_string()
                });
            self
        }
        pub fn wallet_addresses<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.wallet_addresses = value
                .try_into()
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for wallet_addresses failed"
                        .to_string()
                });
            self
        }
        ///Sends a `GET` request to `/v1/wallet/{chain}/pnl-by-wallet`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::PnlDetailsPage>, Error<()>> {
            let Self {
                client,
                chain,
                cursor,
                direction,
                limit,
                token_address,
                wallet_addresses,
            } = self;
            let chain = chain.map_err(Error::InvalidRequest)?;
            let cursor = cursor.map_err(Error::InvalidRequest)?;
            let direction = direction.map_err(Error::InvalidRequest)?;
            let limit = limit.map_err(Error::InvalidRequest)?;
            let token_address = token_address.map_err(Error::InvalidRequest)?;
            let wallet_addresses = wallet_addresses.map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v1/wallet/{}/pnl-by-wallet", client.baseurl, encode_path(& chain
                .to_string()),
            );
            let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
            header_map
                .append(
                    ::reqwest::header::HeaderName::from_static("api-version"),
                    ::reqwest::header::HeaderValue::from_static(
                        super::Client::api_version(),
                    ),
                );
            #[allow(unused_mut)]
            let mut request = client
                .client
                .get(url)
                .header(
                    ::reqwest::header::ACCEPT,
                    ::reqwest::header::HeaderValue::from_static("application/json"),
                )
                .query(&progenitor_middleware_client::QueryParam::new("cursor", &cursor))
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "direction",
                        &direction,
                    ),
                )
                .query(&progenitor_middleware_client::QueryParam::new("limit", &limit))
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "tokenAddress",
                        &token_address,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "walletAddresses",
                        &wallet_addresses,
                    ),
                )
                .headers(header_map)
                .build()?;
            let info = OperationInfo {
                operation_id: "get_pnl_by_wallet",
            };
            client.pre(&mut request, &info).await?;
            let result = client.exec(request, &info).await;
            client.post(&result, &info).await?;
            let response = result?;
            match response.status().as_u16() {
                200u16 => ResponseValue::from_response::<()>(response).await,
                _ => Err(Error::UnexpectedResponse(response)),
            }
        }
    }
    /**Builder for [`Client::get_balance_updates`]

[`Client::get_balance_updates`]: super::Client::get_balance_updates*/
    #[derive(Debug, Clone)]
    pub struct GetBalanceUpdates<'a> {
        client: &'a super::Client,
        chain: Result<types::ChainSymbol, String>,
        wallet_address: Result<::std::string::String, String>,
        change_type: Result<Option<types::BalanceChangeType>, String>,
        cursor: Result<Option<::std::string::String>, String>,
        direction: Result<Option<types::GetBalanceUpdatesDirection>, String>,
        limit: Result<Option<::std::num::NonZeroU64>, String>,
        time_from: Result<Option<i64>, String>,
        time_to: Result<Option<i64>, String>,
        token_address: Result<Option<::std::string::String>, String>,
        type_: Result<Option<types::BalanceTokenType>, String>,
    }
    impl<'a> GetBalanceUpdates<'a> {
        pub fn new(client: &'a super::Client) -> Self {
            Self {
                client: client,
                chain: Err("chain was not initialized".to_string()),
                wallet_address: Err("wallet_address was not initialized".to_string()),
                change_type: Ok(None),
                cursor: Ok(None),
                direction: Ok(None),
                limit: Ok(None),
                time_from: Ok(None),
                time_to: Ok(None),
                token_address: Ok(None),
                type_: Ok(None),
            }
        }
        pub fn chain<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::ChainSymbol>,
        {
            self.chain = value
                .try_into()
                .map_err(|_| "conversion to `ChainSymbol` for chain failed".to_string());
            self
        }
        pub fn wallet_address<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.wallet_address = value
                .try_into()
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for wallet_address failed"
                        .to_string()
                });
            self
        }
        pub fn change_type<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::BalanceChangeType>,
        {
            self.change_type = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `BalanceChangeType` for change_type failed"
                        .to_string()
                });
            self
        }
        pub fn cursor<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.cursor = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for cursor failed"
                        .to_string()
                });
            self
        }
        pub fn direction<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::GetBalanceUpdatesDirection>,
        {
            self.direction = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `GetBalanceUpdatesDirection` for direction failed"
                        .to_string()
                });
            self
        }
        pub fn limit<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::num::NonZeroU64>,
        {
            self.limit = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: num :: NonZeroU64` for limit failed"
                        .to_string()
                });
            self
        }
        pub fn time_from<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<i64>,
        {
            self.time_from = value
                .try_into()
                .map(Some)
                .map_err(|_| "conversion to `i64` for time_from failed".to_string());
            self
        }
        pub fn time_to<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<i64>,
        {
            self.time_to = value
                .try_into()
                .map(Some)
                .map_err(|_| "conversion to `i64` for time_to failed".to_string());
            self
        }
        pub fn token_address<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.token_address = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for token_address failed"
                        .to_string()
                });
            self
        }
        pub fn type_<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::BalanceTokenType>,
        {
            self.type_ = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `BalanceTokenType` for type_ failed".to_string()
                });
            self
        }
        ///Sends a `GET` request to `/v1/wallet/{chain}/{walletAddress}/balance-updates`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::BalanceUpdatePage>, Error<()>> {
            let Self {
                client,
                chain,
                wallet_address,
                change_type,
                cursor,
                direction,
                limit,
                time_from,
                time_to,
                token_address,
                type_,
            } = self;
            let chain = chain.map_err(Error::InvalidRequest)?;
            let wallet_address = wallet_address.map_err(Error::InvalidRequest)?;
            let change_type = change_type.map_err(Error::InvalidRequest)?;
            let cursor = cursor.map_err(Error::InvalidRequest)?;
            let direction = direction.map_err(Error::InvalidRequest)?;
            let limit = limit.map_err(Error::InvalidRequest)?;
            let time_from = time_from.map_err(Error::InvalidRequest)?;
            let time_to = time_to.map_err(Error::InvalidRequest)?;
            let token_address = token_address.map_err(Error::InvalidRequest)?;
            let type_ = type_.map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v1/wallet/{}/{}/balance-updates", client.baseurl, encode_path(& chain
                .to_string()), encode_path(& wallet_address.to_string()),
            );
            let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
            header_map
                .append(
                    ::reqwest::header::HeaderName::from_static("api-version"),
                    ::reqwest::header::HeaderValue::from_static(
                        super::Client::api_version(),
                    ),
                );
            #[allow(unused_mut)]
            let mut request = client
                .client
                .get(url)
                .header(
                    ::reqwest::header::ACCEPT,
                    ::reqwest::header::HeaderValue::from_static("application/json"),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "changeType",
                        &change_type,
                    ),
                )
                .query(&progenitor_middleware_client::QueryParam::new("cursor", &cursor))
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "direction",
                        &direction,
                    ),
                )
                .query(&progenitor_middleware_client::QueryParam::new("limit", &limit))
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "timeFrom",
                        &time_from,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new("timeTo", &time_to),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "tokenAddress",
                        &token_address,
                    ),
                )
                .query(&progenitor_middleware_client::QueryParam::new("type", &type_))
                .headers(header_map)
                .build()?;
            let info = OperationInfo {
                operation_id: "get_balance_updates",
            };
            client.pre(&mut request, &info).await?;
            let result = client.exec(request, &info).await;
            client.post(&result, &info).await?;
            let response = result?;
            match response.status().as_u16() {
                200u16 => ResponseValue::from_response::<()>(response).await,
                _ => Err(Error::UnexpectedResponse(response)),
            }
        }
    }
    /**Builder for [`Client::calculate_pnl`]

[`Client::calculate_pnl`]: super::Client::calculate_pnl*/
    #[derive(Debug, Clone)]
    pub struct CalculatePnl<'a> {
        client: &'a super::Client,
        chain: Result<types::ChainSymbol, String>,
        wallet_address: Result<::std::string::String, String>,
        body: Result<types::builder::CalculatePnlInput, String>,
    }
    impl<'a> CalculatePnl<'a> {
        pub fn new(client: &'a super::Client) -> Self {
            Self {
                client: client,
                chain: Err("chain was not initialized".to_string()),
                wallet_address: Err("wallet_address was not initialized".to_string()),
                body: Ok(::std::default::Default::default()),
            }
        }
        pub fn chain<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::ChainSymbol>,
        {
            self.chain = value
                .try_into()
                .map_err(|_| "conversion to `ChainSymbol` for chain failed".to_string());
            self
        }
        pub fn wallet_address<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.wallet_address = value
                .try_into()
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for wallet_address failed"
                        .to_string()
                });
            self
        }
        pub fn body<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::CalculatePnlInput>,
            <V as std::convert::TryInto<
                types::CalculatePnlInput,
            >>::Error: std::fmt::Display,
        {
            self.body = value
                .try_into()
                .map(From::from)
                .map_err(|s| {
                    format!("conversion to `CalculatePnlInput` for body failed: {}", s)
                });
            self
        }
        pub fn body_map<F>(mut self, f: F) -> Self
        where
            F: std::ops::FnOnce(
                types::builder::CalculatePnlInput,
            ) -> types::builder::CalculatePnlInput,
        {
            self.body = self.body.map(f);
            self
        }
        ///Sends a `POST` request to `/v1/wallet/{chain}/{walletAddress}/calculate-pnl`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::BooleanResultDto>, Error<()>> {
            let Self { client, chain, wallet_address, body } = self;
            let chain = chain.map_err(Error::InvalidRequest)?;
            let wallet_address = wallet_address.map_err(Error::InvalidRequest)?;
            let body = body
                .and_then(|v| {
                    types::CalculatePnlInput::try_from(v).map_err(|e| e.to_string())
                })
                .map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v1/wallet/{}/{}/calculate-pnl", client.baseurl, encode_path(& chain
                .to_string()), encode_path(& wallet_address.to_string()),
            );
            let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
            header_map
                .append(
                    ::reqwest::header::HeaderName::from_static("api-version"),
                    ::reqwest::header::HeaderValue::from_static(
                        super::Client::api_version(),
                    ),
                );
            #[allow(unused_mut)]
            let mut request = client
                .client
                .post(url)
                .header(
                    ::reqwest::header::ACCEPT,
                    ::reqwest::header::HeaderValue::from_static("application/json"),
                )
                .json(&body)
                .headers(header_map)
                .build()?;
            let info = OperationInfo {
                operation_id: "calculate_pnl",
            };
            client.pre(&mut request, &info).await?;
            let result = client.exec(request, &info).await;
            client.post(&result, &info).await?;
            let response = result?;
            match response.status().as_u16() {
                200u16 => ResponseValue::from_response::<()>(response).await,
                _ => Err(Error::UnexpectedResponse(response)),
            }
        }
    }
    /**Builder for [`Client::get_net_worth`]

[`Client::get_net_worth`]: super::Client::get_net_worth*/
    #[derive(Debug, Clone)]
    pub struct GetNetWorth<'a> {
        client: &'a super::Client,
        chain: Result<types::ChainSymbol, String>,
        wallet_address: Result<::std::string::String, String>,
        cursor: Result<Option<::std::string::String>, String>,
        direction: Result<Option<types::GetNetWorthDirection>, String>,
        limit: Result<Option<::std::num::NonZeroU64>, String>,
    }
    impl<'a> GetNetWorth<'a> {
        pub fn new(client: &'a super::Client) -> Self {
            Self {
                client: client,
                chain: Err("chain was not initialized".to_string()),
                wallet_address: Err("wallet_address was not initialized".to_string()),
                cursor: Ok(None),
                direction: Ok(None),
                limit: Ok(None),
            }
        }
        pub fn chain<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::ChainSymbol>,
        {
            self.chain = value
                .try_into()
                .map_err(|_| "conversion to `ChainSymbol` for chain failed".to_string());
            self
        }
        pub fn wallet_address<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.wallet_address = value
                .try_into()
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for wallet_address failed"
                        .to_string()
                });
            self
        }
        pub fn cursor<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.cursor = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for cursor failed"
                        .to_string()
                });
            self
        }
        pub fn direction<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::GetNetWorthDirection>,
        {
            self.direction = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `GetNetWorthDirection` for direction failed"
                        .to_string()
                });
            self
        }
        pub fn limit<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::num::NonZeroU64>,
        {
            self.limit = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: num :: NonZeroU64` for limit failed"
                        .to_string()
                });
            self
        }
        ///Sends a `GET` request to `/v1/wallet/{chain}/{walletAddress}/net-worth`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::WalletNetWorthPage>, Error<()>> {
            let Self { client, chain, wallet_address, cursor, direction, limit } = self;
            let chain = chain.map_err(Error::InvalidRequest)?;
            let wallet_address = wallet_address.map_err(Error::InvalidRequest)?;
            let cursor = cursor.map_err(Error::InvalidRequest)?;
            let direction = direction.map_err(Error::InvalidRequest)?;
            let limit = limit.map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v1/wallet/{}/{}/net-worth", client.baseurl, encode_path(& chain
                .to_string()), encode_path(& wallet_address.to_string()),
            );
            let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
            header_map
                .append(
                    ::reqwest::header::HeaderName::from_static("api-version"),
                    ::reqwest::header::HeaderValue::from_static(
                        super::Client::api_version(),
                    ),
                );
            #[allow(unused_mut)]
            let mut request = client
                .client
                .get(url)
                .header(
                    ::reqwest::header::ACCEPT,
                    ::reqwest::header::HeaderValue::from_static("application/json"),
                )
                .query(&progenitor_middleware_client::QueryParam::new("cursor", &cursor))
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "direction",
                        &direction,
                    ),
                )
                .query(&progenitor_middleware_client::QueryParam::new("limit", &limit))
                .headers(header_map)
                .build()?;
            let info = OperationInfo {
                operation_id: "get_net_worth",
            };
            client.pre(&mut request, &info).await?;
            let result = client.exec(request, &info).await;
            client.post(&result, &info).await?;
            let response = result?;
            match response.status().as_u16() {
                200u16 => ResponseValue::from_response::<()>(response).await,
                _ => Err(Error::UnexpectedResponse(response)),
            }
        }
    }
    /**Builder for [`Client::get_net_worth_chart`]

[`Client::get_net_worth_chart`]: super::Client::get_net_worth_chart*/
    #[derive(Debug, Clone)]
    pub struct GetNetWorthChart<'a> {
        client: &'a super::Client,
        chain: Result<types::ChainSymbol, String>,
        wallet_address: Result<::std::string::String, String>,
        hours: Result<Option<::std::num::NonZeroU32>, String>,
    }
    impl<'a> GetNetWorthChart<'a> {
        pub fn new(client: &'a super::Client) -> Self {
            Self {
                client: client,
                chain: Err("chain was not initialized".to_string()),
                wallet_address: Err("wallet_address was not initialized".to_string()),
                hours: Ok(None),
            }
        }
        pub fn chain<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::ChainSymbol>,
        {
            self.chain = value
                .try_into()
                .map_err(|_| "conversion to `ChainSymbol` for chain failed".to_string());
            self
        }
        pub fn wallet_address<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.wallet_address = value
                .try_into()
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for wallet_address failed"
                        .to_string()
                });
            self
        }
        pub fn hours<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::num::NonZeroU32>,
        {
            self.hours = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: num :: NonZeroU32` for hours failed"
                        .to_string()
                });
            self
        }
        ///Sends a `GET` request to `/v1/wallet/{chain}/{walletAddress}/net-worth-chart`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::WalletNetWorthChartDto>, Error<()>> {
            let Self { client, chain, wallet_address, hours } = self;
            let chain = chain.map_err(Error::InvalidRequest)?;
            let wallet_address = wallet_address.map_err(Error::InvalidRequest)?;
            let hours = hours.map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v1/wallet/{}/{}/net-worth-chart", client.baseurl, encode_path(& chain
                .to_string()), encode_path(& wallet_address.to_string()),
            );
            let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
            header_map
                .append(
                    ::reqwest::header::HeaderName::from_static("api-version"),
                    ::reqwest::header::HeaderValue::from_static(
                        super::Client::api_version(),
                    ),
                );
            #[allow(unused_mut)]
            let mut request = client
                .client
                .get(url)
                .header(
                    ::reqwest::header::ACCEPT,
                    ::reqwest::header::HeaderValue::from_static("application/json"),
                )
                .query(&progenitor_middleware_client::QueryParam::new("hours", &hours))
                .headers(header_map)
                .build()?;
            let info = OperationInfo {
                operation_id: "get_net_worth_chart",
            };
            client.pre(&mut request, &info).await?;
            let result = client.exec(request, &info).await;
            client.post(&result, &info).await?;
            let response = result?;
            match response.status().as_u16() {
                200u16 => ResponseValue::from_response::<()>(response).await,
                _ => Err(Error::UnexpectedResponse(response)),
            }
        }
    }
    /**Builder for [`Client::get_net_worth_details`]

[`Client::get_net_worth_details`]: super::Client::get_net_worth_details*/
    #[derive(Debug, Clone)]
    pub struct GetNetWorthDetails<'a> {
        client: &'a super::Client,
        chain: Result<types::ChainSymbol, String>,
        wallet_address: Result<::std::string::String, String>,
        cursor: Result<Option<::std::string::String>, String>,
        direction: Result<Option<types::GetNetWorthDetailsDirection>, String>,
        hours: Result<Option<i32>, String>,
        limit: Result<Option<::std::num::NonZeroU64>, String>,
    }
    impl<'a> GetNetWorthDetails<'a> {
        pub fn new(client: &'a super::Client) -> Self {
            Self {
                client: client,
                chain: Err("chain was not initialized".to_string()),
                wallet_address: Err("wallet_address was not initialized".to_string()),
                cursor: Ok(None),
                direction: Ok(None),
                hours: Ok(None),
                limit: Ok(None),
            }
        }
        pub fn chain<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::ChainSymbol>,
        {
            self.chain = value
                .try_into()
                .map_err(|_| "conversion to `ChainSymbol` for chain failed".to_string());
            self
        }
        pub fn wallet_address<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.wallet_address = value
                .try_into()
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for wallet_address failed"
                        .to_string()
                });
            self
        }
        pub fn cursor<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.cursor = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for cursor failed"
                        .to_string()
                });
            self
        }
        pub fn direction<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::GetNetWorthDetailsDirection>,
        {
            self.direction = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `GetNetWorthDetailsDirection` for direction failed"
                        .to_string()
                });
            self
        }
        pub fn hours<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<i32>,
        {
            self.hours = value
                .try_into()
                .map(Some)
                .map_err(|_| "conversion to `i32` for hours failed".to_string());
            self
        }
        pub fn limit<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::num::NonZeroU64>,
        {
            self.limit = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: num :: NonZeroU64` for limit failed"
                        .to_string()
                });
            self
        }
        ///Sends a `GET` request to `/v1/wallet/{chain}/{walletAddress}/net-worth-details`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::WalletNetWorthDetailsPage>, Error<()>> {
            let Self {
                client,
                chain,
                wallet_address,
                cursor,
                direction,
                hours,
                limit,
            } = self;
            let chain = chain.map_err(Error::InvalidRequest)?;
            let wallet_address = wallet_address.map_err(Error::InvalidRequest)?;
            let cursor = cursor.map_err(Error::InvalidRequest)?;
            let direction = direction.map_err(Error::InvalidRequest)?;
            let hours = hours.map_err(Error::InvalidRequest)?;
            let limit = limit.map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v1/wallet/{}/{}/net-worth-details", client.baseurl, encode_path(&
                chain.to_string()), encode_path(& wallet_address.to_string()),
            );
            let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
            header_map
                .append(
                    ::reqwest::header::HeaderName::from_static("api-version"),
                    ::reqwest::header::HeaderValue::from_static(
                        super::Client::api_version(),
                    ),
                );
            #[allow(unused_mut)]
            let mut request = client
                .client
                .get(url)
                .header(
                    ::reqwest::header::ACCEPT,
                    ::reqwest::header::HeaderValue::from_static("application/json"),
                )
                .query(&progenitor_middleware_client::QueryParam::new("cursor", &cursor))
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "direction",
                        &direction,
                    ),
                )
                .query(&progenitor_middleware_client::QueryParam::new("hours", &hours))
                .query(&progenitor_middleware_client::QueryParam::new("limit", &limit))
                .headers(header_map)
                .build()?;
            let info = OperationInfo {
                operation_id: "get_net_worth_details",
            };
            client.pre(&mut request, &info).await?;
            let result = client.exec(request, &info).await;
            client.post(&result, &info).await?;
            let response = result?;
            match response.status().as_u16() {
                200u16 => ResponseValue::from_response::<()>(response).await,
                _ => Err(Error::UnexpectedResponse(response)),
            }
        }
    }
    /**Builder for [`Client::get_pnl`]

[`Client::get_pnl`]: super::Client::get_pnl*/
    #[derive(Debug, Clone)]
    pub struct GetPnl<'a> {
        client: &'a super::Client,
        chain: Result<types::ChainSymbol, String>,
        wallet_address: Result<::std::string::String, String>,
        resolution: Result<Option<types::PnlResolution>, String>,
    }
    impl<'a> GetPnl<'a> {
        pub fn new(client: &'a super::Client) -> Self {
            Self {
                client: client,
                chain: Err("chain was not initialized".to_string()),
                wallet_address: Err("wallet_address was not initialized".to_string()),
                resolution: Ok(None),
            }
        }
        pub fn chain<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::ChainSymbol>,
        {
            self.chain = value
                .try_into()
                .map_err(|_| "conversion to `ChainSymbol` for chain failed".to_string());
            self
        }
        pub fn wallet_address<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.wallet_address = value
                .try_into()
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for wallet_address failed"
                        .to_string()
                });
            self
        }
        pub fn resolution<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::PnlResolution>,
        {
            self.resolution = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `PnlResolution` for resolution failed".to_string()
                });
            self
        }
        ///Sends a `GET` request to `/v1/wallet/{chain}/{walletAddress}/pnl`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::WalletPnlSummaryDto>, Error<()>> {
            let Self { client, chain, wallet_address, resolution } = self;
            let chain = chain.map_err(Error::InvalidRequest)?;
            let wallet_address = wallet_address.map_err(Error::InvalidRequest)?;
            let resolution = resolution.map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v1/wallet/{}/{}/pnl", client.baseurl, encode_path(& chain
                .to_string()), encode_path(& wallet_address.to_string()),
            );
            let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
            header_map
                .append(
                    ::reqwest::header::HeaderName::from_static("api-version"),
                    ::reqwest::header::HeaderValue::from_static(
                        super::Client::api_version(),
                    ),
                );
            #[allow(unused_mut)]
            let mut request = client
                .client
                .get(url)
                .header(
                    ::reqwest::header::ACCEPT,
                    ::reqwest::header::HeaderValue::from_static("application/json"),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "resolution",
                        &resolution,
                    ),
                )
                .headers(header_map)
                .build()?;
            let info = OperationInfo {
                operation_id: "get_pnl",
            };
            client.pre(&mut request, &info).await?;
            let result = client.exec(request, &info).await;
            client.post(&result, &info).await?;
            let response = result?;
            match response.status().as_u16() {
                200u16 => ResponseValue::from_response::<()>(response).await,
                _ => Err(Error::UnexpectedResponse(response)),
            }
        }
    }
    /**Builder for [`Client::get_pnl_by_token`]

[`Client::get_pnl_by_token`]: super::Client::get_pnl_by_token*/
    #[derive(Debug, Clone)]
    pub struct GetPnlByToken<'a> {
        client: &'a super::Client,
        chain: Result<types::ChainSymbol, String>,
        wallet_address: Result<::std::string::String, String>,
        cursor: Result<Option<::std::string::String>, String>,
        direction: Result<Option<types::GetPnlByTokenDirection>, String>,
        limit: Result<Option<::std::num::NonZeroU64>, String>,
        token_addresses: Result<::std::string::String, String>,
    }
    impl<'a> GetPnlByToken<'a> {
        pub fn new(client: &'a super::Client) -> Self {
            Self {
                client: client,
                chain: Err("chain was not initialized".to_string()),
                wallet_address: Err("wallet_address was not initialized".to_string()),
                cursor: Ok(None),
                direction: Ok(None),
                limit: Ok(None),
                token_addresses: Err("token_addresses was not initialized".to_string()),
            }
        }
        pub fn chain<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::ChainSymbol>,
        {
            self.chain = value
                .try_into()
                .map_err(|_| "conversion to `ChainSymbol` for chain failed".to_string());
            self
        }
        pub fn wallet_address<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.wallet_address = value
                .try_into()
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for wallet_address failed"
                        .to_string()
                });
            self
        }
        pub fn cursor<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.cursor = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for cursor failed"
                        .to_string()
                });
            self
        }
        pub fn direction<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::GetPnlByTokenDirection>,
        {
            self.direction = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `GetPnlByTokenDirection` for direction failed"
                        .to_string()
                });
            self
        }
        pub fn limit<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::num::NonZeroU64>,
        {
            self.limit = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: num :: NonZeroU64` for limit failed"
                        .to_string()
                });
            self
        }
        pub fn token_addresses<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.token_addresses = value
                .try_into()
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for token_addresses failed"
                        .to_string()
                });
            self
        }
        ///Sends a `GET` request to `/v1/wallet/{chain}/{walletAddress}/pnl-by-token`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::PnlDetailsPage>, Error<()>> {
            let Self {
                client,
                chain,
                wallet_address,
                cursor,
                direction,
                limit,
                token_addresses,
            } = self;
            let chain = chain.map_err(Error::InvalidRequest)?;
            let wallet_address = wallet_address.map_err(Error::InvalidRequest)?;
            let cursor = cursor.map_err(Error::InvalidRequest)?;
            let direction = direction.map_err(Error::InvalidRequest)?;
            let limit = limit.map_err(Error::InvalidRequest)?;
            let token_addresses = token_addresses.map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v1/wallet/{}/{}/pnl-by-token", client.baseurl, encode_path(& chain
                .to_string()), encode_path(& wallet_address.to_string()),
            );
            let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
            header_map
                .append(
                    ::reqwest::header::HeaderName::from_static("api-version"),
                    ::reqwest::header::HeaderValue::from_static(
                        super::Client::api_version(),
                    ),
                );
            #[allow(unused_mut)]
            let mut request = client
                .client
                .get(url)
                .header(
                    ::reqwest::header::ACCEPT,
                    ::reqwest::header::HeaderValue::from_static("application/json"),
                )
                .query(&progenitor_middleware_client::QueryParam::new("cursor", &cursor))
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "direction",
                        &direction,
                    ),
                )
                .query(&progenitor_middleware_client::QueryParam::new("limit", &limit))
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "tokenAddresses",
                        &token_addresses,
                    ),
                )
                .headers(header_map)
                .build()?;
            let info = OperationInfo {
                operation_id: "get_pnl_by_token",
            };
            client.pre(&mut request, &info).await?;
            let result = client.exec(request, &info).await;
            client.post(&result, &info).await?;
            let response = result?;
            match response.status().as_u16() {
                200u16 => ResponseValue::from_response::<()>(response).await,
                _ => Err(Error::UnexpectedResponse(response)),
            }
        }
    }
    /**Builder for [`Client::get_pnl_details`]

[`Client::get_pnl_details`]: super::Client::get_pnl_details*/
    #[derive(Debug, Clone)]
    pub struct GetPnlDetails<'a> {
        client: &'a super::Client,
        chain: Result<types::ChainSymbol, String>,
        wallet_address: Result<::std::string::String, String>,
        cursor: Result<Option<::std::string::String>, String>,
        direction: Result<Option<types::GetPnlDetailsDirection>, String>,
        limit: Result<Option<::std::num::NonZeroU64>, String>,
    }
    impl<'a> GetPnlDetails<'a> {
        pub fn new(client: &'a super::Client) -> Self {
            Self {
                client: client,
                chain: Err("chain was not initialized".to_string()),
                wallet_address: Err("wallet_address was not initialized".to_string()),
                cursor: Ok(None),
                direction: Ok(None),
                limit: Ok(None),
            }
        }
        pub fn chain<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::ChainSymbol>,
        {
            self.chain = value
                .try_into()
                .map_err(|_| "conversion to `ChainSymbol` for chain failed".to_string());
            self
        }
        pub fn wallet_address<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.wallet_address = value
                .try_into()
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for wallet_address failed"
                        .to_string()
                });
            self
        }
        pub fn cursor<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.cursor = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for cursor failed"
                        .to_string()
                });
            self
        }
        pub fn direction<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::GetPnlDetailsDirection>,
        {
            self.direction = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `GetPnlDetailsDirection` for direction failed"
                        .to_string()
                });
            self
        }
        pub fn limit<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::num::NonZeroU64>,
        {
            self.limit = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: num :: NonZeroU64` for limit failed"
                        .to_string()
                });
            self
        }
        ///Sends a `GET` request to `/v1/wallet/{chain}/{walletAddress}/pnl-details`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::PnlDetailsPage>, Error<()>> {
            let Self { client, chain, wallet_address, cursor, direction, limit } = self;
            let chain = chain.map_err(Error::InvalidRequest)?;
            let wallet_address = wallet_address.map_err(Error::InvalidRequest)?;
            let cursor = cursor.map_err(Error::InvalidRequest)?;
            let direction = direction.map_err(Error::InvalidRequest)?;
            let limit = limit.map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v1/wallet/{}/{}/pnl-details", client.baseurl, encode_path(& chain
                .to_string()), encode_path(& wallet_address.to_string()),
            );
            let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
            header_map
                .append(
                    ::reqwest::header::HeaderName::from_static("api-version"),
                    ::reqwest::header::HeaderValue::from_static(
                        super::Client::api_version(),
                    ),
                );
            #[allow(unused_mut)]
            let mut request = client
                .client
                .get(url)
                .header(
                    ::reqwest::header::ACCEPT,
                    ::reqwest::header::HeaderValue::from_static("application/json"),
                )
                .query(&progenitor_middleware_client::QueryParam::new("cursor", &cursor))
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "direction",
                        &direction,
                    ),
                )
                .query(&progenitor_middleware_client::QueryParam::new("limit", &limit))
                .headers(header_map)
                .build()?;
            let info = OperationInfo {
                operation_id: "get_pnl_details",
            };
            client.pre(&mut request, &info).await?;
            let result = client.exec(request, &info).await;
            client.post(&result, &info).await?;
            let response = result?;
            match response.status().as_u16() {
                200u16 => ResponseValue::from_response::<()>(response).await,
                _ => Err(Error::UnexpectedResponse(response)),
            }
        }
    }
    /**Builder for [`Client::get_tokens_balance`]

[`Client::get_tokens_balance`]: super::Client::get_tokens_balance*/
    #[derive(Debug, Clone)]
    pub struct GetTokensBalance<'a> {
        client: &'a super::Client,
        chain: Result<types::ChainSymbol, String>,
        wallet_address: Result<::std::string::String, String>,
        cursor: Result<Option<::std::string::String>, String>,
        direction: Result<Option<types::GetTokensBalanceDirection>, String>,
        limit: Result<Option<::std::num::NonZeroU64>, String>,
    }
    impl<'a> GetTokensBalance<'a> {
        pub fn new(client: &'a super::Client) -> Self {
            Self {
                client: client,
                chain: Err("chain was not initialized".to_string()),
                wallet_address: Err("wallet_address was not initialized".to_string()),
                cursor: Ok(None),
                direction: Ok(None),
                limit: Ok(None),
            }
        }
        pub fn chain<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::ChainSymbol>,
        {
            self.chain = value
                .try_into()
                .map_err(|_| "conversion to `ChainSymbol` for chain failed".to_string());
            self
        }
        pub fn wallet_address<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.wallet_address = value
                .try_into()
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for wallet_address failed"
                        .to_string()
                });
            self
        }
        pub fn cursor<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.cursor = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for cursor failed"
                        .to_string()
                });
            self
        }
        pub fn direction<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::GetTokensBalanceDirection>,
        {
            self.direction = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `GetTokensBalanceDirection` for direction failed"
                        .to_string()
                });
            self
        }
        pub fn limit<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::num::NonZeroU64>,
        {
            self.limit = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: num :: NonZeroU64` for limit failed"
                        .to_string()
                });
            self
        }
        ///Sends a `GET` request to `/v1/wallet/{chain}/{walletAddress}/tokens-balance`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::TokensBalancePage>, Error<()>> {
            let Self { client, chain, wallet_address, cursor, direction, limit } = self;
            let chain = chain.map_err(Error::InvalidRequest)?;
            let wallet_address = wallet_address.map_err(Error::InvalidRequest)?;
            let cursor = cursor.map_err(Error::InvalidRequest)?;
            let direction = direction.map_err(Error::InvalidRequest)?;
            let limit = limit.map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v1/wallet/{}/{}/tokens-balance", client.baseurl, encode_path(& chain
                .to_string()), encode_path(& wallet_address.to_string()),
            );
            let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
            header_map
                .append(
                    ::reqwest::header::HeaderName::from_static("api-version"),
                    ::reqwest::header::HeaderValue::from_static(
                        super::Client::api_version(),
                    ),
                );
            #[allow(unused_mut)]
            let mut request = client
                .client
                .get(url)
                .header(
                    ::reqwest::header::ACCEPT,
                    ::reqwest::header::HeaderValue::from_static("application/json"),
                )
                .query(&progenitor_middleware_client::QueryParam::new("cursor", &cursor))
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "direction",
                        &direction,
                    ),
                )
                .query(&progenitor_middleware_client::QueryParam::new("limit", &limit))
                .headers(header_map)
                .build()?;
            let info = OperationInfo {
                operation_id: "get_tokens_balance",
            };
            client.pre(&mut request, &info).await?;
            let result = client.exec(request, &info).await;
            client.post(&result, &info).await?;
            let response = result?;
            match response.status().as_u16() {
                200u16 => ResponseValue::from_response::<()>(response).await,
                _ => Err(Error::UnexpectedResponse(response)),
            }
        }
    }
    /**Builder for [`Client::get_wallet_transfer_total`]

[`Client::get_wallet_transfer_total`]: super::Client::get_wallet_transfer_total*/
    #[derive(Debug, Clone)]
    pub struct GetWalletTransferTotal<'a> {
        client: &'a super::Client,
        chain: Result<types::ChainSymbol, String>,
        wallet_address: Result<::std::string::String, String>,
        after_timestamp: Result<Option<i64>, String>,
        before_timestamp: Result<Option<i64>, String>,
        cursor: Result<Option<::std::string::String>, String>,
        direction: Result<Option<types::GetWalletTransferTotalDirection>, String>,
        limit: Result<Option<::std::num::NonZeroU64>, String>,
        max_token_amount: Result<Option<::std::string::String>, String>,
        max_token_amount_in_usd: Result<Option<::std::string::String>, String>,
        min_token_amount: Result<Option<::std::string::String>, String>,
        min_token_amount_in_usd: Result<Option<::std::string::String>, String>,
        token_address: Result<Option<::std::string::String>, String>,
    }
    impl<'a> GetWalletTransferTotal<'a> {
        pub fn new(client: &'a super::Client) -> Self {
            Self {
                client: client,
                chain: Err("chain was not initialized".to_string()),
                wallet_address: Err("wallet_address was not initialized".to_string()),
                after_timestamp: Ok(None),
                before_timestamp: Ok(None),
                cursor: Ok(None),
                direction: Ok(None),
                limit: Ok(None),
                max_token_amount: Ok(None),
                max_token_amount_in_usd: Ok(None),
                min_token_amount: Ok(None),
                min_token_amount_in_usd: Ok(None),
                token_address: Ok(None),
            }
        }
        pub fn chain<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::ChainSymbol>,
        {
            self.chain = value
                .try_into()
                .map_err(|_| "conversion to `ChainSymbol` for chain failed".to_string());
            self
        }
        pub fn wallet_address<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.wallet_address = value
                .try_into()
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for wallet_address failed"
                        .to_string()
                });
            self
        }
        pub fn after_timestamp<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<i64>,
        {
            self.after_timestamp = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `i64` for after_timestamp failed".to_string()
                });
            self
        }
        pub fn before_timestamp<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<i64>,
        {
            self.before_timestamp = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `i64` for before_timestamp failed".to_string()
                });
            self
        }
        pub fn cursor<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.cursor = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for cursor failed"
                        .to_string()
                });
            self
        }
        pub fn direction<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::GetWalletTransferTotalDirection>,
        {
            self.direction = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `GetWalletTransferTotalDirection` for direction failed"
                        .to_string()
                });
            self
        }
        pub fn limit<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::num::NonZeroU64>,
        {
            self.limit = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: num :: NonZeroU64` for limit failed"
                        .to_string()
                });
            self
        }
        pub fn max_token_amount<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.max_token_amount = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for max_token_amount failed"
                        .to_string()
                });
            self
        }
        pub fn max_token_amount_in_usd<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.max_token_amount_in_usd = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for max_token_amount_in_usd failed"
                        .to_string()
                });
            self
        }
        pub fn min_token_amount<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.min_token_amount = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for min_token_amount failed"
                        .to_string()
                });
            self
        }
        pub fn min_token_amount_in_usd<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.min_token_amount_in_usd = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for min_token_amount_in_usd failed"
                        .to_string()
                });
            self
        }
        pub fn token_address<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.token_address = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for token_address failed"
                        .to_string()
                });
            self
        }
        ///Sends a `GET` request to `/v1/wallet/{chain}/{walletAddress}/transfer-total`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::TokenTransferTotalDto>, Error<()>> {
            let Self {
                client,
                chain,
                wallet_address,
                after_timestamp,
                before_timestamp,
                cursor,
                direction,
                limit,
                max_token_amount,
                max_token_amount_in_usd,
                min_token_amount,
                min_token_amount_in_usd,
                token_address,
            } = self;
            let chain = chain.map_err(Error::InvalidRequest)?;
            let wallet_address = wallet_address.map_err(Error::InvalidRequest)?;
            let after_timestamp = after_timestamp.map_err(Error::InvalidRequest)?;
            let before_timestamp = before_timestamp.map_err(Error::InvalidRequest)?;
            let cursor = cursor.map_err(Error::InvalidRequest)?;
            let direction = direction.map_err(Error::InvalidRequest)?;
            let limit = limit.map_err(Error::InvalidRequest)?;
            let max_token_amount = max_token_amount.map_err(Error::InvalidRequest)?;
            let max_token_amount_in_usd = max_token_amount_in_usd
                .map_err(Error::InvalidRequest)?;
            let min_token_amount = min_token_amount.map_err(Error::InvalidRequest)?;
            let min_token_amount_in_usd = min_token_amount_in_usd
                .map_err(Error::InvalidRequest)?;
            let token_address = token_address.map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v1/wallet/{}/{}/transfer-total", client.baseurl, encode_path(& chain
                .to_string()), encode_path(& wallet_address.to_string()),
            );
            let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
            header_map
                .append(
                    ::reqwest::header::HeaderName::from_static("api-version"),
                    ::reqwest::header::HeaderValue::from_static(
                        super::Client::api_version(),
                    ),
                );
            #[allow(unused_mut)]
            let mut request = client
                .client
                .get(url)
                .header(
                    ::reqwest::header::ACCEPT,
                    ::reqwest::header::HeaderValue::from_static("application/json"),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "afterTimestamp",
                        &after_timestamp,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "beforeTimestamp",
                        &before_timestamp,
                    ),
                )
                .query(&progenitor_middleware_client::QueryParam::new("cursor", &cursor))
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "direction",
                        &direction,
                    ),
                )
                .query(&progenitor_middleware_client::QueryParam::new("limit", &limit))
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "maxTokenAmount",
                        &max_token_amount,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "maxTokenAmountInUsd",
                        &max_token_amount_in_usd,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "minTokenAmount",
                        &min_token_amount,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "minTokenAmountInUsd",
                        &min_token_amount_in_usd,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "tokenAddress",
                        &token_address,
                    ),
                )
                .headers(header_map)
                .build()?;
            let info = OperationInfo {
                operation_id: "get_wallet_transfer_total",
            };
            client.pre(&mut request, &info).await?;
            let result = client.exec(request, &info).await;
            client.post(&result, &info).await?;
            let response = result?;
            match response.status().as_u16() {
                200u16 => ResponseValue::from_response::<()>(response).await,
                _ => Err(Error::UnexpectedResponse(response)),
            }
        }
    }
    /**Builder for [`Client::get_wallet_transfers`]

[`Client::get_wallet_transfers`]: super::Client::get_wallet_transfers*/
    #[derive(Debug, Clone)]
    pub struct GetWalletTransfers<'a> {
        client: &'a super::Client,
        chain: Result<types::ChainSymbol, String>,
        wallet_address: Result<::std::string::String, String>,
        after_timestamp: Result<Option<i64>, String>,
        before_timestamp: Result<Option<i64>, String>,
        cursor: Result<Option<::std::string::String>, String>,
        direction: Result<Option<types::GetWalletTransfersDirection>, String>,
        limit: Result<Option<::std::num::NonZeroU64>, String>,
        max_token_amount: Result<Option<::std::string::String>, String>,
        max_token_amount_in_usd: Result<Option<::std::string::String>, String>,
        min_token_amount: Result<Option<::std::string::String>, String>,
        min_token_amount_in_usd: Result<Option<::std::string::String>, String>,
        token_address: Result<Option<::std::string::String>, String>,
    }
    impl<'a> GetWalletTransfers<'a> {
        pub fn new(client: &'a super::Client) -> Self {
            Self {
                client: client,
                chain: Err("chain was not initialized".to_string()),
                wallet_address: Err("wallet_address was not initialized".to_string()),
                after_timestamp: Ok(None),
                before_timestamp: Ok(None),
                cursor: Ok(None),
                direction: Ok(None),
                limit: Ok(None),
                max_token_amount: Ok(None),
                max_token_amount_in_usd: Ok(None),
                min_token_amount: Ok(None),
                min_token_amount_in_usd: Ok(None),
                token_address: Ok(None),
            }
        }
        pub fn chain<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::ChainSymbol>,
        {
            self.chain = value
                .try_into()
                .map_err(|_| "conversion to `ChainSymbol` for chain failed".to_string());
            self
        }
        pub fn wallet_address<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.wallet_address = value
                .try_into()
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for wallet_address failed"
                        .to_string()
                });
            self
        }
        pub fn after_timestamp<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<i64>,
        {
            self.after_timestamp = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `i64` for after_timestamp failed".to_string()
                });
            self
        }
        pub fn before_timestamp<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<i64>,
        {
            self.before_timestamp = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `i64` for before_timestamp failed".to_string()
                });
            self
        }
        pub fn cursor<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.cursor = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for cursor failed"
                        .to_string()
                });
            self
        }
        pub fn direction<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::GetWalletTransfersDirection>,
        {
            self.direction = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `GetWalletTransfersDirection` for direction failed"
                        .to_string()
                });
            self
        }
        pub fn limit<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::num::NonZeroU64>,
        {
            self.limit = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: num :: NonZeroU64` for limit failed"
                        .to_string()
                });
            self
        }
        pub fn max_token_amount<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.max_token_amount = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for max_token_amount failed"
                        .to_string()
                });
            self
        }
        pub fn max_token_amount_in_usd<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.max_token_amount_in_usd = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for max_token_amount_in_usd failed"
                        .to_string()
                });
            self
        }
        pub fn min_token_amount<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.min_token_amount = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for min_token_amount failed"
                        .to_string()
                });
            self
        }
        pub fn min_token_amount_in_usd<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.min_token_amount_in_usd = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for min_token_amount_in_usd failed"
                        .to_string()
                });
            self
        }
        pub fn token_address<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.token_address = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for token_address failed"
                        .to_string()
                });
            self
        }
        ///Sends a `GET` request to `/v1/wallet/{chain}/{walletAddress}/transfers`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::TransactionHistoryPage>, Error<()>> {
            let Self {
                client,
                chain,
                wallet_address,
                after_timestamp,
                before_timestamp,
                cursor,
                direction,
                limit,
                max_token_amount,
                max_token_amount_in_usd,
                min_token_amount,
                min_token_amount_in_usd,
                token_address,
            } = self;
            let chain = chain.map_err(Error::InvalidRequest)?;
            let wallet_address = wallet_address.map_err(Error::InvalidRequest)?;
            let after_timestamp = after_timestamp.map_err(Error::InvalidRequest)?;
            let before_timestamp = before_timestamp.map_err(Error::InvalidRequest)?;
            let cursor = cursor.map_err(Error::InvalidRequest)?;
            let direction = direction.map_err(Error::InvalidRequest)?;
            let limit = limit.map_err(Error::InvalidRequest)?;
            let max_token_amount = max_token_amount.map_err(Error::InvalidRequest)?;
            let max_token_amount_in_usd = max_token_amount_in_usd
                .map_err(Error::InvalidRequest)?;
            let min_token_amount = min_token_amount.map_err(Error::InvalidRequest)?;
            let min_token_amount_in_usd = min_token_amount_in_usd
                .map_err(Error::InvalidRequest)?;
            let token_address = token_address.map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v1/wallet/{}/{}/transfers", client.baseurl, encode_path(& chain
                .to_string()), encode_path(& wallet_address.to_string()),
            );
            let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
            header_map
                .append(
                    ::reqwest::header::HeaderName::from_static("api-version"),
                    ::reqwest::header::HeaderValue::from_static(
                        super::Client::api_version(),
                    ),
                );
            #[allow(unused_mut)]
            let mut request = client
                .client
                .get(url)
                .header(
                    ::reqwest::header::ACCEPT,
                    ::reqwest::header::HeaderValue::from_static("application/json"),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "afterTimestamp",
                        &after_timestamp,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "beforeTimestamp",
                        &before_timestamp,
                    ),
                )
                .query(&progenitor_middleware_client::QueryParam::new("cursor", &cursor))
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "direction",
                        &direction,
                    ),
                )
                .query(&progenitor_middleware_client::QueryParam::new("limit", &limit))
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "maxTokenAmount",
                        &max_token_amount,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "maxTokenAmountInUsd",
                        &max_token_amount_in_usd,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "minTokenAmount",
                        &min_token_amount,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "minTokenAmountInUsd",
                        &min_token_amount_in_usd,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "tokenAddress",
                        &token_address,
                    ),
                )
                .headers(header_map)
                .build()?;
            let info = OperationInfo {
                operation_id: "get_wallet_transfers",
            };
            client.pre(&mut request, &info).await?;
            let result = client.exec(request, &info).await;
            client.post(&result, &info).await?;
            let response = result?;
            match response.status().as_u16() {
                200u16 => ResponseValue::from_response::<()>(response).await,
                _ => Err(Error::UnexpectedResponse(response)),
            }
        }
    }
    /**Builder for [`Client::watchlist_add`]

[`Client::watchlist_add`]: super::Client::watchlist_add*/
    #[derive(Debug, Clone)]
    pub struct WatchlistAdd<'a> {
        client: &'a super::Client,
        chain: Result<types::ChainSymbol, String>,
        wallet_address: Result<::std::string::String, String>,
    }
    impl<'a> WatchlistAdd<'a> {
        pub fn new(client: &'a super::Client) -> Self {
            Self {
                client: client,
                chain: Err("chain was not initialized".to_string()),
                wallet_address: Err("wallet_address was not initialized".to_string()),
            }
        }
        pub fn chain<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::ChainSymbol>,
        {
            self.chain = value
                .try_into()
                .map_err(|_| "conversion to `ChainSymbol` for chain failed".to_string());
            self
        }
        pub fn wallet_address<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.wallet_address = value
                .try_into()
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for wallet_address failed"
                        .to_string()
                });
            self
        }
        ///Sends a `POST` request to `/v1/watchlist/{chain}/{walletAddress}`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::BooleanResultDto>, Error<()>> {
            let Self { client, chain, wallet_address } = self;
            let chain = chain.map_err(Error::InvalidRequest)?;
            let wallet_address = wallet_address.map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v1/watchlist/{}/{}", client.baseurl, encode_path(& chain
                .to_string()), encode_path(& wallet_address.to_string()),
            );
            let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
            header_map
                .append(
                    ::reqwest::header::HeaderName::from_static("api-version"),
                    ::reqwest::header::HeaderValue::from_static(
                        super::Client::api_version(),
                    ),
                );
            #[allow(unused_mut)]
            let mut request = client
                .client
                .post(url)
                .header(
                    ::reqwest::header::ACCEPT,
                    ::reqwest::header::HeaderValue::from_static("application/json"),
                )
                .headers(header_map)
                .build()?;
            let info = OperationInfo {
                operation_id: "watchlist_add",
            };
            client.pre(&mut request, &info).await?;
            let result = client.exec(request, &info).await;
            client.post(&result, &info).await?;
            let response = result?;
            match response.status().as_u16() {
                200u16 => ResponseValue::from_response::<()>(response).await,
                _ => Err(Error::UnexpectedResponse(response)),
            }
        }
    }
    /**Builder for [`Client::list_endpoints`]

[`Client::list_endpoints`]: super::Client::list_endpoints*/
    #[derive(Debug, Clone)]
    pub struct ListEndpoints<'a> {
        client: &'a super::Client,
        iterator: Result<Option<::std::string::String>, String>,
        limit: Result<Option<::std::num::NonZeroU64>, String>,
        order: Result<Option<types::ListEndpointsOrder>, String>,
    }
    impl<'a> ListEndpoints<'a> {
        pub fn new(client: &'a super::Client) -> Self {
            Self {
                client: client,
                iterator: Ok(None),
                limit: Ok(None),
                order: Ok(None),
            }
        }
        pub fn iterator<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.iterator = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for iterator failed"
                        .to_string()
                });
            self
        }
        pub fn limit<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::num::NonZeroU64>,
        {
            self.limit = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: num :: NonZeroU64` for limit failed"
                        .to_string()
                });
            self
        }
        pub fn order<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::ListEndpointsOrder>,
        {
            self.order = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `ListEndpointsOrder` for order failed".to_string()
                });
            self
        }
        ///Sends a `GET` request to `/v1/webhook/endpoint`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::EndpointListResponse>, Error<()>> {
            let Self { client, iterator, limit, order } = self;
            let iterator = iterator.map_err(Error::InvalidRequest)?;
            let limit = limit.map_err(Error::InvalidRequest)?;
            let order = order.map_err(Error::InvalidRequest)?;
            let url = format!("{}/v1/webhook/endpoint", client.baseurl,);
            let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
            header_map
                .append(
                    ::reqwest::header::HeaderName::from_static("api-version"),
                    ::reqwest::header::HeaderValue::from_static(
                        super::Client::api_version(),
                    ),
                );
            #[allow(unused_mut)]
            let mut request = client
                .client
                .get(url)
                .header(
                    ::reqwest::header::ACCEPT,
                    ::reqwest::header::HeaderValue::from_static("application/json"),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new("iterator", &iterator),
                )
                .query(&progenitor_middleware_client::QueryParam::new("limit", &limit))
                .query(&progenitor_middleware_client::QueryParam::new("order", &order))
                .headers(header_map)
                .build()?;
            let info = OperationInfo {
                operation_id: "list_endpoints",
            };
            client.pre(&mut request, &info).await?;
            let result = client.exec(request, &info).await;
            client.post(&result, &info).await?;
            let response = result?;
            match response.status().as_u16() {
                200u16 => ResponseValue::from_response::<()>(response).await,
                _ => Err(Error::UnexpectedResponse(response)),
            }
        }
    }
    /**Builder for [`Client::create_endpoint`]

[`Client::create_endpoint`]: super::Client::create_endpoint*/
    #[derive(Debug, Clone)]
    pub struct CreateEndpoint<'a> {
        client: &'a super::Client,
        body: Result<types::builder::CreateEndpointInput, String>,
    }
    impl<'a> CreateEndpoint<'a> {
        pub fn new(client: &'a super::Client) -> Self {
            Self {
                client: client,
                body: Ok(::std::default::Default::default()),
            }
        }
        pub fn body<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::CreateEndpointInput>,
            <V as std::convert::TryInto<
                types::CreateEndpointInput,
            >>::Error: std::fmt::Display,
        {
            self.body = value
                .try_into()
                .map(From::from)
                .map_err(|s| {
                    format!("conversion to `CreateEndpointInput` for body failed: {}", s)
                });
            self
        }
        pub fn body_map<F>(mut self, f: F) -> Self
        where
            F: std::ops::FnOnce(
                types::builder::CreateEndpointInput,
            ) -> types::builder::CreateEndpointInput,
        {
            self.body = self.body.map(f);
            self
        }
        ///Sends a `POST` request to `/v1/webhook/endpoint`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::EndpointResponse>, Error<()>> {
            let Self { client, body } = self;
            let body = body
                .and_then(|v| {
                    types::CreateEndpointInput::try_from(v).map_err(|e| e.to_string())
                })
                .map_err(Error::InvalidRequest)?;
            let url = format!("{}/v1/webhook/endpoint", client.baseurl,);
            let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
            header_map
                .append(
                    ::reqwest::header::HeaderName::from_static("api-version"),
                    ::reqwest::header::HeaderValue::from_static(
                        super::Client::api_version(),
                    ),
                );
            #[allow(unused_mut)]
            let mut request = client
                .client
                .post(url)
                .header(
                    ::reqwest::header::ACCEPT,
                    ::reqwest::header::HeaderValue::from_static("application/json"),
                )
                .json(&body)
                .headers(header_map)
                .build()?;
            let info = OperationInfo {
                operation_id: "create_endpoint",
            };
            client.pre(&mut request, &info).await?;
            let result = client.exec(request, &info).await;
            client.post(&result, &info).await?;
            let response = result?;
            match response.status().as_u16() {
                200u16 => ResponseValue::from_response::<()>(response).await,
                _ => Err(Error::UnexpectedResponse(response)),
            }
        }
    }
    /**Builder for [`Client::update_endpoint`]

[`Client::update_endpoint`]: super::Client::update_endpoint*/
    #[derive(Debug, Clone)]
    pub struct UpdateEndpoint<'a> {
        client: &'a super::Client,
        body: Result<types::builder::UpdateEndpointInput, String>,
    }
    impl<'a> UpdateEndpoint<'a> {
        pub fn new(client: &'a super::Client) -> Self {
            Self {
                client: client,
                body: Ok(::std::default::Default::default()),
            }
        }
        pub fn body<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::UpdateEndpointInput>,
            <V as std::convert::TryInto<
                types::UpdateEndpointInput,
            >>::Error: std::fmt::Display,
        {
            self.body = value
                .try_into()
                .map(From::from)
                .map_err(|s| {
                    format!("conversion to `UpdateEndpointInput` for body failed: {}", s)
                });
            self
        }
        pub fn body_map<F>(mut self, f: F) -> Self
        where
            F: std::ops::FnOnce(
                types::builder::UpdateEndpointInput,
            ) -> types::builder::UpdateEndpointInput,
        {
            self.body = self.body.map(f);
            self
        }
        ///Sends a `PATCH` request to `/v1/webhook/endpoint`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::EndpointResponse>, Error<()>> {
            let Self { client, body } = self;
            let body = body
                .and_then(|v| {
                    types::UpdateEndpointInput::try_from(v).map_err(|e| e.to_string())
                })
                .map_err(Error::InvalidRequest)?;
            let url = format!("{}/v1/webhook/endpoint", client.baseurl,);
            let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
            header_map
                .append(
                    ::reqwest::header::HeaderName::from_static("api-version"),
                    ::reqwest::header::HeaderValue::from_static(
                        super::Client::api_version(),
                    ),
                );
            #[allow(unused_mut)]
            let mut request = client
                .client
                .patch(url)
                .header(
                    ::reqwest::header::ACCEPT,
                    ::reqwest::header::HeaderValue::from_static("application/json"),
                )
                .json(&body)
                .headers(header_map)
                .build()?;
            let info = OperationInfo {
                operation_id: "update_endpoint",
            };
            client.pre(&mut request, &info).await?;
            let result = client.exec(request, &info).await;
            client.post(&result, &info).await?;
            let response = result?;
            match response.status().as_u16() {
                200u16 => ResponseValue::from_response::<()>(response).await,
                _ => Err(Error::UnexpectedResponse(response)),
            }
        }
    }
    /**Builder for [`Client::get_endpoint`]

[`Client::get_endpoint`]: super::Client::get_endpoint*/
    #[derive(Debug, Clone)]
    pub struct GetEndpoint<'a> {
        client: &'a super::Client,
        id: Result<::std::string::String, String>,
    }
    impl<'a> GetEndpoint<'a> {
        pub fn new(client: &'a super::Client) -> Self {
            Self {
                client: client,
                id: Err("id was not initialized".to_string()),
            }
        }
        pub fn id<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.id = value
                .try_into()
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for id failed"
                        .to_string()
                });
            self
        }
        ///Sends a `GET` request to `/v1/webhook/endpoint/{id}`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::EndpointResponse>, Error<()>> {
            let Self { client, id } = self;
            let id = id.map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v1/webhook/endpoint/{}", client.baseurl, encode_path(& id
                .to_string()),
            );
            let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
            header_map
                .append(
                    ::reqwest::header::HeaderName::from_static("api-version"),
                    ::reqwest::header::HeaderValue::from_static(
                        super::Client::api_version(),
                    ),
                );
            #[allow(unused_mut)]
            let mut request = client
                .client
                .get(url)
                .header(
                    ::reqwest::header::ACCEPT,
                    ::reqwest::header::HeaderValue::from_static("application/json"),
                )
                .headers(header_map)
                .build()?;
            let info = OperationInfo {
                operation_id: "get_endpoint",
            };
            client.pre(&mut request, &info).await?;
            let result = client.exec(request, &info).await;
            client.post(&result, &info).await?;
            let response = result?;
            match response.status().as_u16() {
                200u16 => ResponseValue::from_response::<()>(response).await,
                _ => Err(Error::UnexpectedResponse(response)),
            }
        }
    }
    /**Builder for [`Client::delete_endpoint`]

[`Client::delete_endpoint`]: super::Client::delete_endpoint*/
    #[derive(Debug, Clone)]
    pub struct DeleteEndpoint<'a> {
        client: &'a super::Client,
        id: Result<::std::string::String, String>,
    }
    impl<'a> DeleteEndpoint<'a> {
        pub fn new(client: &'a super::Client) -> Self {
            Self {
                client: client,
                id: Err("id was not initialized".to_string()),
            }
        }
        pub fn id<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.id = value
                .try_into()
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for id failed"
                        .to_string()
                });
            self
        }
        ///Sends a `DELETE` request to `/v1/webhook/endpoint/{id}`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::EndpointOperationResponse>, Error<()>> {
            let Self { client, id } = self;
            let id = id.map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v1/webhook/endpoint/{}", client.baseurl, encode_path(& id
                .to_string()),
            );
            let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
            header_map
                .append(
                    ::reqwest::header::HeaderName::from_static("api-version"),
                    ::reqwest::header::HeaderValue::from_static(
                        super::Client::api_version(),
                    ),
                );
            #[allow(unused_mut)]
            let mut request = client
                .client
                .delete(url)
                .header(
                    ::reqwest::header::ACCEPT,
                    ::reqwest::header::HeaderValue::from_static("application/json"),
                )
                .headers(header_map)
                .build()?;
            let info = OperationInfo {
                operation_id: "delete_endpoint",
            };
            client.pre(&mut request, &info).await?;
            let result = client.exec(request, &info).await;
            client.post(&result, &info).await?;
            let response = result?;
            match response.status().as_u16() {
                200u16 => ResponseValue::from_response::<()>(response).await,
                _ => Err(Error::UnexpectedResponse(response)),
            }
        }
    }
    /**Builder for [`Client::get_endpoint_secret`]

[`Client::get_endpoint_secret`]: super::Client::get_endpoint_secret*/
    #[derive(Debug, Clone)]
    pub struct GetEndpointSecret<'a> {
        client: &'a super::Client,
        id: Result<::std::string::String, String>,
    }
    impl<'a> GetEndpointSecret<'a> {
        pub fn new(client: &'a super::Client) -> Self {
            Self {
                client: client,
                id: Err("id was not initialized".to_string()),
            }
        }
        pub fn id<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.id = value
                .try_into()
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for id failed"
                        .to_string()
                });
            self
        }
        ///Sends a `GET` request to `/v1/webhook/endpoint/{id}/secret`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::EndpointSecretResponse>, Error<()>> {
            let Self { client, id } = self;
            let id = id.map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v1/webhook/endpoint/{}/secret", client.baseurl, encode_path(& id
                .to_string()),
            );
            let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
            header_map
                .append(
                    ::reqwest::header::HeaderName::from_static("api-version"),
                    ::reqwest::header::HeaderValue::from_static(
                        super::Client::api_version(),
                    ),
                );
            #[allow(unused_mut)]
            let mut request = client
                .client
                .get(url)
                .header(
                    ::reqwest::header::ACCEPT,
                    ::reqwest::header::HeaderValue::from_static("application/json"),
                )
                .headers(header_map)
                .build()?;
            let info = OperationInfo {
                operation_id: "get_endpoint_secret",
            };
            client.pre(&mut request, &info).await?;
            let result = client.exec(request, &info).await;
            client.post(&result, &info).await?;
            let response = result?;
            match response.status().as_u16() {
                200u16 => ResponseValue::from_response::<()>(response).await,
                _ => Err(Error::UnexpectedResponse(response)),
            }
        }
    }
    /**Builder for [`Client::rotate_endpoint_secret`]

[`Client::rotate_endpoint_secret`]: super::Client::rotate_endpoint_secret*/
    #[derive(Debug, Clone)]
    pub struct RotateEndpointSecret<'a> {
        client: &'a super::Client,
        id: Result<::std::string::String, String>,
    }
    impl<'a> RotateEndpointSecret<'a> {
        pub fn new(client: &'a super::Client) -> Self {
            Self {
                client: client,
                id: Err("id was not initialized".to_string()),
            }
        }
        pub fn id<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.id = value
                .try_into()
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for id failed"
                        .to_string()
                });
            self
        }
        ///Sends a `POST` request to `/v1/webhook/endpoint/{id}/secret/rotate`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::EndpointOperationResponse>, Error<()>> {
            let Self { client, id } = self;
            let id = id.map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v1/webhook/endpoint/{}/secret/rotate", client.baseurl, encode_path(&
                id.to_string()),
            );
            let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
            header_map
                .append(
                    ::reqwest::header::HeaderName::from_static("api-version"),
                    ::reqwest::header::HeaderValue::from_static(
                        super::Client::api_version(),
                    ),
                );
            #[allow(unused_mut)]
            let mut request = client
                .client
                .post(url)
                .header(
                    ::reqwest::header::ACCEPT,
                    ::reqwest::header::HeaderValue::from_static("application/json"),
                )
                .headers(header_map)
                .build()?;
            let info = OperationInfo {
                operation_id: "rotate_endpoint_secret",
            };
            client.pre(&mut request, &info).await?;
            let result = client.exec(request, &info).await;
            client.post(&result, &info).await?;
            let response = result?;
            match response.status().as_u16() {
                200u16 => ResponseValue::from_response::<()>(response).await,
                _ => Err(Error::UnexpectedResponse(response)),
            }
        }
    }
}
/// Items consumers will typically use such as the Client.
pub mod prelude {
    pub use self::super::Client;
}
