#[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())
            }
        }
    }
    ///Sort field for activities query
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Sort field for activities query",
    ///  "type": "string",
    ///  "enum": [
    ///    "timestamp",
    ///    "totalUsd"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum ActivitySortBy {
        #[serde(rename = "timestamp")]
        Timestamp,
        #[serde(rename = "totalUsd")]
        TotalUsd,
    }
    impl ::std::convert::From<&Self> for ActivitySortBy {
        fn from(value: &ActivitySortBy) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for ActivitySortBy {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::Timestamp => f.write_str("timestamp"),
                Self::TotalUsd => f.write_str("totalUsd"),
            }
        }
    }
    impl ::std::str::FromStr for ActivitySortBy {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "timestamp" => Ok(Self::Timestamp),
                "totalUsd" => Ok(Self::TotalUsd),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for ActivitySortBy {
        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 ActivitySortBy {
        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 ActivitySortBy {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    ///Activity type (extends TradeType)
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Activity type (extends TradeType)",
    ///  "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 ActivityType {
        #[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 ActivityType {
        fn from(value: &ActivityType) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for ActivityType {
        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 ActivityType {
        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 ActivityType {
        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 ActivityType {
        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 ActivityType {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    ///Balance change type
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Balance change type",
    ///  "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()
        }
    }
    ///Balance token type
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Balance token type",
    ///  "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()
        }
    }
    ///Balance update record
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Balance update record",
    ///  "type": "object",
    ///  "required": [
    ///    "accountOwnerAddress",
    ///    "balanceChange",
    ///    "balanceChangeInNative",
    ///    "balanceChangeInUsd",
    ///    "blockHash",
    ///    "blockHeight",
    ///    "blockTimestamp",
    ///    "changeType",
    ///    "index",
    ///    "postBalance",
    ///    "postBalanceInNative",
    ///    "postBalanceInUsd",
    ///    "preBalance",
    ///    "preBalanceInNative",
    ///    "preBalanceInUsd",
    ///    "tokenAccountAddress",
    ///    "tokenAddress",
    ///    "transactionSignature",
    ///    "type"
    ///  ],
    ///  "properties": {
    ///    "accountOwnerAddress": {
    ///      "description": "Account owner wallet address",
    ///      "type": "string"
    ///    },
    ///    "balanceChange": {
    ///      "description": "Balance change amount",
    ///      "type": "string"
    ///    },
    ///    "balanceChangeInNative": {
    ///      "description": "Balance change in native token",
    ///      "type": "string"
    ///    },
    ///    "balanceChangeInUsd": {
    ///      "description": "Balance change in USD",
    ///      "type": "string"
    ///    },
    ///    "blockHash": {
    ///      "description": "Block hash",
    ///      "type": "string"
    ///    },
    ///    "blockHeight": {
    ///      "description": "Block height",
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "blockSlot": {
    ///      "description": "Block slot number",
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "blockTimestamp": {
    ///      "description": "Block timestamp (milliseconds)",
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "changeType": {
    ///      "$ref": "#/components/schemas/BalanceChangeType"
    ///    },
    ///    "index": {
    ///      "description": "Transaction instruction index",
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "postBalance": {
    ///      "description": "Balance after the transaction",
    ///      "type": "string"
    ///    },
    ///    "postBalanceInNative": {
    ///      "description": "Balance after in native token",
    ///      "type": "string"
    ///    },
    ///    "postBalanceInUsd": {
    ///      "description": "Balance after in USD",
    ///      "type": "string"
    ///    },
    ///    "preBalance": {
    ///      "description": "Balance before the transaction",
    ///      "type": "string"
    ///    },
    ///    "preBalanceInNative": {
    ///      "description": "Balance before in native token",
    ///      "type": "string"
    ///    },
    ///    "preBalanceInUsd": {
    ///      "description": "Balance before in USD",
    ///      "type": "string"
    ///    },
    ///    "tokenAccountAddress": {
    ///      "description": "Token account address",
    ///      "type": "string"
    ///    },
    ///    "tokenAddress": {
    ///      "description": "Token contract address",
    ///      "type": "string"
    ///    },
    ///    "transactionSignature": {
    ///      "description": "Transaction signature",
    ///      "type": "string"
    ///    },
    ///    "type": {
    ///      "$ref": "#/components/schemas/BalanceTokenType"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct BalanceUpdate {
        ///Account owner wallet address
        #[serde(rename = "accountOwnerAddress")]
        pub account_owner_address: ::std::string::String,
        ///Balance change amount
        #[serde(rename = "balanceChange")]
        pub balance_change: ::std::string::String,
        ///Balance change in native token
        #[serde(rename = "balanceChangeInNative")]
        pub balance_change_in_native: ::std::string::String,
        ///Balance change in USD
        #[serde(rename = "balanceChangeInUsd")]
        pub balance_change_in_usd: ::std::string::String,
        ///Block hash
        #[serde(rename = "blockHash")]
        pub block_hash: ::std::string::String,
        ///Block height
        #[serde(rename = "blockHeight")]
        pub block_height: i64,
        ///Block slot number
        #[serde(
            rename = "blockSlot",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub block_slot: ::std::option::Option<i64>,
        ///Block timestamp (milliseconds)
        #[serde(rename = "blockTimestamp")]
        pub block_timestamp: i64,
        #[serde(rename = "changeType")]
        pub change_type: BalanceChangeType,
        ///Transaction instruction index
        pub index: i64,
        ///Balance after the transaction
        #[serde(rename = "postBalance")]
        pub post_balance: ::std::string::String,
        ///Balance after in native token
        #[serde(rename = "postBalanceInNative")]
        pub post_balance_in_native: ::std::string::String,
        ///Balance after in USD
        #[serde(rename = "postBalanceInUsd")]
        pub post_balance_in_usd: ::std::string::String,
        ///Balance before the transaction
        #[serde(rename = "preBalance")]
        pub pre_balance: ::std::string::String,
        ///Balance before in native token
        #[serde(rename = "preBalanceInNative")]
        pub pre_balance_in_native: ::std::string::String,
        ///Balance before in USD
        #[serde(rename = "preBalanceInUsd")]
        pub pre_balance_in_usd: ::std::string::String,
        ///Token account address
        #[serde(rename = "tokenAccountAddress")]
        pub token_account_address: ::std::string::String,
        ///Token contract address
        #[serde(rename = "tokenAddress")]
        pub token_address: ::std::string::String,
        ///Transaction signature
        #[serde(rename = "transactionSignature")]
        pub transaction_signature: ::std::string::String,
        #[serde(rename = "type")]
        pub type_: BalanceTokenType,
    }
    impl ::std::convert::From<&BalanceUpdate> for BalanceUpdate {
        fn from(value: &BalanceUpdate) -> Self {
            value.clone()
        }
    }
    impl BalanceUpdate {
        pub fn builder() -> builder::BalanceUpdate {
            Default::default()
        }
    }
    ///Blockchain information
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Blockchain information",
    ///  "type": "object",
    ///  "required": [
    ///    "chainId",
    ///    "explorerUrl",
    ///    "name",
    ///    "symbol"
    ///  ],
    ///  "properties": {
    ///    "chainId": {
    ///      "description": "Blockchain chain ID",
    ///      "examples": [
    ///        1
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "explorerUrl": {
    ///      "description": "Blockchain explorer URL",
    ///      "examples": [
    ///        "https://explorer.solana.com"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "name": {
    ///      "description": "Blockchain display name",
    ///      "examples": [
    ///        "Solana"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "symbol": {
    ///      "description": "Blockchain ticker symbol",
    ///      "examples": [
    ///        "SOL"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct Blockchain {
        ///Blockchain chain ID
        #[serde(rename = "chainId")]
        pub chain_id: i64,
        ///Blockchain explorer URL
        #[serde(rename = "explorerUrl")]
        pub explorer_url: ::std::string::String,
        ///Blockchain display name
        pub name: ::std::string::String,
        ///Blockchain ticker symbol
        pub symbol: ::std::string::String,
    }
    impl ::std::convert::From<&Blockchain> for Blockchain {
        fn from(value: &Blockchain) -> Self {
            value.clone()
        }
    }
    impl Blockchain {
        pub fn builder() -> builder::Blockchain {
            Default::default()
        }
    }
    ///`BlockchainLatestBlock`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "blockhash",
    ///    "lastValidBlockHeight"
    ///  ],
    ///  "properties": {
    ///    "blockhash": {
    ///      "description": "Latest block hash",
    ///      "examples": [
    ///        "123"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "lastValidBlockHeight": {
    ///      "description": "Last valid block height",
    ///      "examples": [
    ///        123
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct BlockchainLatestBlock {
        ///Latest block hash
        pub blockhash: ::std::string::String,
        ///Last valid block height
        #[serde(rename = "lastValidBlockHeight")]
        pub last_valid_block_height: i64,
    }
    impl ::std::convert::From<&BlockchainLatestBlock> for BlockchainLatestBlock {
        fn from(value: &BlockchainLatestBlock) -> Self {
            value.clone()
        }
    }
    impl BlockchainLatestBlock {
        pub fn builder() -> builder::BlockchainLatestBlock {
            Default::default()
        }
    }
    ///Boolean result response
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Boolean result response",
    ///  "type": "object",
    ///  "required": [
    ///    "result"
    ///  ],
    ///  "properties": {
    ///    "result": {
    ///      "description": "Boolean result value",
    ///      "examples": [
    ///        true
    ///      ],
    ///      "type": "boolean"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct BooleanResult {
        ///Boolean result value
        pub result: bool,
    }
    impl ::std::convert::From<&BooleanResult> for BooleanResult {
        fn from(value: &BooleanResult) -> Self {
            value.clone()
        }
    }
    impl BooleanResult {
        pub fn builder() -> builder::BooleanResult {
            Default::default()
        }
    }
    ///`CalculatePnlInput`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "properties": {
    ///    "tokenAddresses": {
    ///      "description": "List of token addresses to calculate PnL for",
    ///      "examples": [
    ///        [
    ///          "6p6xgHyF7AeE6TZkSmFsko444wqoP15icUSqi2jfGiPN",
    ///          "So11111111111111111111111111111111111111112"
    ///        ]
    ///      ],
    ///      "type": "array",
    ///      "items": {
    ///        "type": "string"
    ///      }
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct CalculatePnlInput {
        ///List of token addresses to calculate PnL for
        #[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()
        }
    }
    ///Supported blockchain chains
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Supported blockchain chains",
    ///  "type": "string",
    ///  "enum": [
    ///    "sol",
    ///    "eth",
    ///    "bsc"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum ChainSymbol {
        #[serde(rename = "sol")]
        Sol,
        #[serde(rename = "eth")]
        Eth,
        #[serde(rename = "bsc")]
        Bsc,
    }
    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::Eth => f.write_str("eth"),
                Self::Bsc => f.write_str("bsc"),
            }
        }
    }
    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),
                "eth" => Ok(Self::Eth),
                "bsc" => Ok(Self::Bsc),
                _ => 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()
        }
    }
    ///Claimer wallet address
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Claimer wallet address",
    ///  "type": "object",
    ///  "required": [
    ///    "claimer"
    ///  ],
    ///  "properties": {
    ///    "claimer": {
    ///      "description": "Claimer wallet address",
    ///      "examples": [
    ///        "Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "packetId": {
    ///      "description": "Red packet on-chain ID",
    ///      "examples": [
    ///        "Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "password": {
    ///      "description": "Red packet password for claiming",
    ///      "examples": [
    ///        "123456"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "shareId": {
    ///      "description": "Share identifier",
    ///      "examples": [
    ///        "abc123"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct ClaimRedPacketRequest {
        ///Claimer wallet address
        pub claimer: ::std::string::String,
        ///Red packet on-chain ID
        #[serde(
            rename = "packetId",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub packet_id: ::std::option::Option<::std::string::String>,
        ///Red packet password for claiming
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub password: ::std::option::Option<::std::string::String>,
        ///Share identifier
        #[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<&ClaimRedPacketRequest> for ClaimRedPacketRequest {
        fn from(value: &ClaimRedPacketRequest) -> Self {
            value.clone()
        }
    }
    impl ClaimRedPacketRequest {
        pub fn builder() -> builder::ClaimRedPacketRequest {
            Default::default()
        }
    }
    ///Claim red packet response
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Claim red packet response",
    ///  "type": "object",
    ///  "required": [
    ///    "txSerialize"
    ///  ],
    ///  "properties": {
    ///    "txSerialize": {
    ///      "description": "Serialized transaction data",
    ///      "examples": [
    ///        "AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAEDRg..."
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct ClaimRedPacketResponse {
        ///Serialized transaction data
        #[serde(rename = "txSerialize")]
        pub tx_serialize: ::std::string::String,
    }
    impl ::std::convert::From<&ClaimRedPacketResponse> for ClaimRedPacketResponse {
        fn from(value: &ClaimRedPacketResponse) -> Self {
            value.clone()
        }
    }
    impl ClaimRedPacketResponse {
        pub fn builder() -> builder::ClaimRedPacketResponse {
            Default::default()
        }
    }
    ///Creator wallet address
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Creator wallet address",
    ///  "type": "object",
    ///  "required": [
    ///    "creator",
    ///    "maxClaims",
    ///    "mint"
    ///  ],
    ///  "properties": {
    ///    "claimAuthority": {
    ///      "description": "Claim authority address",
    ///      "examples": [
    ///        "Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "creator": {
    ///      "description": "Creator wallet address",
    ///      "examples": [
    ///        "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "expiration": {
    ///      "description": "Expiration duration in seconds",
    ///      "examples": [
    ///        24
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "fixedAmount": {
    ///      "description": "Fixed amount per claim",
    ///      "examples": [
    ///        "1000000000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "maxClaims": {
    ///      "description": "Maximum number of claims allowed",
    ///      "examples": [
    ///        10
    ///      ],
    ///      "type": "integer",
    ///      "format": "int32"
    ///    },
    ///    "memo": {
    ///      "description": "Red packet memo message",
    ///      "examples": [
    ///        "Happy Red Packet"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "mint": {
    ///      "description": "Token mint address",
    ///      "examples": [
    ///        "Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "password": {
    ///      "description": "Red packet password for claiming",
    ///      "examples": [
    ///        "123456"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "totalAmount": {
    ///      "description": "Total amount in the red packet",
    ///      "examples": [
    ///        "1000000000"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct CreateRedPacketRequest {
        ///Claim authority address
        #[serde(
            rename = "claimAuthority",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub claim_authority: ::std::option::Option<::std::string::String>,
        ///Creator wallet address
        pub creator: ::std::string::String,
        ///Expiration duration in seconds
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub expiration: ::std::option::Option<i64>,
        ///Fixed amount per claim
        #[serde(
            rename = "fixedAmount",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub fixed_amount: ::std::option::Option<::std::string::String>,
        ///Maximum number of claims allowed
        #[serde(rename = "maxClaims")]
        pub max_claims: i32,
        ///Red packet memo message
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub memo: ::std::option::Option<::std::string::String>,
        ///Token mint address
        pub mint: ::std::string::String,
        ///Red packet password for claiming
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub password: ::std::option::Option<::std::string::String>,
        ///Total amount in the red packet
        #[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<&CreateRedPacketRequest> for CreateRedPacketRequest {
        fn from(value: &CreateRedPacketRequest) -> Self {
            value.clone()
        }
    }
    impl CreateRedPacketRequest {
        pub fn builder() -> builder::CreateRedPacketRequest {
            Default::default()
        }
    }
    ///Create red packet response
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Create red packet response",
    ///  "type": "object",
    ///  "required": [
    ///    "shareId",
    ///    "txSerialize"
    ///  ],
    ///  "properties": {
    ///    "shareId": {
    ///      "description": "Share identifier",
    ///      "examples": [
    ///        "abc123"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "txSerialize": {
    ///      "description": "Serialized transaction data",
    ///      "examples": [
    ///        "AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAEDRg..."
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct CreateRedPacketResponse {
        ///Share identifier
        #[serde(rename = "shareId")]
        pub share_id: ::std::string::String,
        ///Serialized transaction data
        #[serde(rename = "txSerialize")]
        pub tx_serialize: ::std::string::String,
    }
    impl ::std::convert::From<&CreateRedPacketResponse> for CreateRedPacketResponse {
        fn from(value: &CreateRedPacketResponse) -> Self {
            value.clone()
        }
    }
    impl CreateRedPacketResponse {
        pub fn builder() -> builder::CreateRedPacketResponse {
            Default::default()
        }
    }
    ///`CreateTokenInput`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "dex",
    ///    "name",
    ///    "symbol",
    ///    "userAddress"
    ///  ],
    ///  "properties": {
    ///    "dex": {
    ///      "description": "DEX identifier for the trade",
    ///      "examples": [
    ///        "raydium"
    ///      ],
    ///      "type": "string",
    ///      "enum": [
    ///        "raydium",
    ///        "pumpfun",
    ///        "moonshot",
    ///        "candy",
    ///        "launchpad"
    ///      ]
    ///    },
    ///    "extra": {
    ///      "description": "Additional metadata about the created token",
    ///      "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": "Token image URL (Base64 or HTTPS)",
    ///      "examples": [
    ///        "https://assets.candyproject.com/token/icon.png"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "name": {
    ///      "description": "Name of the token to be created",
    ///      "examples": [
    ///        "Candy Token"
    ///      ],
    ///      "type": "string",
    ///      "maxLength": 32,
    ///      "minLength": 1
    ///    },
    ///    "priorityFee": {
    ///      "description": "Priority fee in SOL to increase transaction processing speed",
    ///      "examples": [
    ///        "1000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "symbol": {
    ///      "description": "Token symbol/ticker",
    ///      "examples": [
    ///        "CANDY"
    ///      ],
    ///      "type": "string",
    ///      "maxLength": 10,
    ///      "minLength": 1
    ///    },
    ///    "uri": {
    ///      "description": "URI for token metadata (usually points to image or JSON)",
    ///      "examples": [
    ///        "https://assets.candyproject.com/token/icon.png"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "userAddress": {
    ///      "description": "Public key of the wallet initiating the transaction",
    ///      "examples": [
    ///        "oQPnhXAbLbMuKHESaGrbXT17CyvWCpLyERSJA9HCYd7"
    ///      ],
    ///      "type": "string",
    ///      "maxLength": 64,
    ///      "minLength": 8
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct CreateTokenInput {
        ///DEX identifier for the trade
        pub dex: CreateTokenInputDex,
        ///Additional metadata about the created token
        #[serde(default, skip_serializing_if = "::serde_json::Map::is_empty")]
        pub extra: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
        ///Token image URL (Base64 or HTTPS)
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub image: ::std::option::Option<::std::string::String>,
        ///Name of the token to be created
        pub name: CreateTokenInputName,
        ///Priority fee in SOL to increase transaction processing speed
        #[serde(
            rename = "priorityFee",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub priority_fee: ::std::option::Option<::std::string::String>,
        ///Token symbol/ticker
        pub symbol: CreateTokenInputSymbol,
        ///URI for token metadata (usually points to image or JSON)
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub uri: ::std::option::Option<::std::string::String>,
        ///Public key of the wallet initiating the transaction
        #[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()
        }
    }
    ///DEX identifier for the trade
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "DEX identifier for the trade",
    ///  "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()
        }
    }
    ///Name of the token to be created
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Name of the token to be created",
    ///  "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())
                })
        }
    }
    ///Token symbol/ticker
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Token symbol/ticker",
    ///  "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())
                })
        }
    }
    ///Public key of the wallet initiating the transaction
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Public key of the wallet initiating the transaction",
    ///  "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": "Token mint address that requires signature for the transaction",
    ///      "examples": [
    ///        "So11111111111111111111111111111111111111112"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "serializedTx": {
    ///      "description": "Base64 encoded transaction for token creation",
    ///      "examples": [
    ///        "AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAEDRgYGpQEDAQIABQcICQoLDA0ODwAAAAAAAAAAAAAQERITFBUWFxgZGhscHR4fAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA="
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct CreateTokenReply {
        ///Token mint address that requires signature for the transaction
        #[serde(rename = "mintAddress")]
        pub mint_address: ::std::string::String,
        ///Base64 encoded transaction for token creation
        #[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()
        }
    }
    ///Request to create a webhook endpoint
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Request to create a webhook endpoint",
    ///  "type": "object",
    ///  "required": [
    ///    "url"
    ///  ],
    ///  "properties": {
    ///    "channels": {
    ///      "description": "Webhook event channels to subscribe to",
    ///      "type": "array",
    ///      "items": {
    ///        "$ref": "#/components/schemas/WebhookChannel"
    ///      }
    ///    },
    ///    "description": {
    ///      "description": "Endpoint description",
    ///      "examples": [
    ///        "Webhook description"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "disabled": {
    ///      "description": "Whether the endpoint is disabled",
    ///      "examples": [
    ///        false
    ///      ],
    ///      "type": "boolean"
    ///    },
    ///    "filter": {
    ///      "description": "Event filter configuration",
    ///      "type": "string"
    ///    },
    ///    "filterTypes": {
    ///      "description": "Event type filters",
    ///      "type": "array",
    ///      "items": {
    ///        "type": "string"
    ///      }
    ///    },
    ///    "metadata": {
    ///      "description": "Endpoint metadata",
    ///      "examples": [
    ///        {
    ///          "key": "value"
    ///        }
    ///      ],
    ///      "type": "object",
    ///      "additionalProperties": {}
    ///    },
    ///    "rateLimit": {
    ///      "description": "Rate limit for the endpoint",
    ///      "examples": [
    ///        1000
    ///      ],
    ///      "type": "integer",
    ///      "format": "int32",
    ///      "minimum": 0.0
    ///    },
    ///    "secret": {
    ///      "description": "Endpoint signing secret",
    ///      "type": "string"
    ///    },
    ///    "url": {
    ///      "description": "Webhook destination URL",
    ///      "examples": [
    ///        "https://example.com"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct CreateWebhookRequest {
        ///Webhook event channels to subscribe to
        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
        pub channels: ::std::vec::Vec<WebhookChannel>,
        ///Endpoint description
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub description: ::std::option::Option<::std::string::String>,
        ///Whether the endpoint is disabled
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub disabled: ::std::option::Option<bool>,
        ///Event filter configuration
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub filter: ::std::option::Option<::std::string::String>,
        ///Event type filters
        #[serde(
            rename = "filterTypes",
            default,
            skip_serializing_if = "::std::vec::Vec::is_empty"
        )]
        pub filter_types: ::std::vec::Vec<::std::string::String>,
        ///Endpoint metadata
        #[serde(default, skip_serializing_if = "::serde_json::Map::is_empty")]
        pub metadata: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
        ///Rate limit for the endpoint
        #[serde(
            rename = "rateLimit",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub rate_limit: ::std::option::Option<i32>,
        ///Endpoint signing secret
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub secret: ::std::option::Option<::std::string::String>,
        ///Webhook destination URL
        pub url: ::std::string::String,
    }
    impl ::std::convert::From<&CreateWebhookRequest> for CreateWebhookRequest {
        fn from(value: &CreateWebhookRequest) -> Self {
            value.clone()
        }
    }
    impl CreateWebhookRequest {
        pub fn builder() -> builder::CreateWebhookRequest {
            Default::default()
        }
    }
    ///Token info returned by `get_dev_tokens` — mirrors TS `DevTokenDTO`.
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Token info returned by `get_dev_tokens` — mirrors TS `DevTokenDTO`.",
    ///  "type": "object",
    ///  "required": [
    ///    "address",
    ///    "marketData",
    ///    "metadata",
    ///    "stats"
    ///  ],
    ///  "properties": {
    ///    "address": {
    ///      "description": "Token address",
    ///      "examples": [
    ///        "6p6xgHyF7AeE6TZkSmFsko444wqoP15icUSqi2jfGiPN"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "marketData": {
    ///      "$ref": "#/components/schemas/TokenMarketData"
    ///    },
    ///    "metadata": {
    ///      "$ref": "#/components/schemas/TokenMetadata"
    ///    },
    ///    "stats": {
    ///      "$ref": "#/components/schemas/TokenStats"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct DevToken {
        ///Token address
        pub address: ::std::string::String,
        #[serde(rename = "marketData")]
        pub market_data: TokenMarketData,
        pub metadata: TokenMetadata,
        pub stats: TokenStats,
    }
    impl ::std::convert::From<&DevToken> for DevToken {
        fn from(value: &DevToken) -> Self {
            value.clone()
        }
    }
    impl DevToken {
        pub fn builder() -> builder::DevToken {
            Default::default()
        }
    }
    ///DEX information
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "DEX information",
    ///  "type": "object",
    ///  "required": [
    ///    "chain"
    ///  ],
    ///  "properties": {
    ///    "chain": {
    ///      "description": "Chain identifier",
    ///      "examples": [
    ///        "sol"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "image": {
    ///      "description": "DEX image URL",
    ///      "examples": [
    ///        "https://example.com/dex-logo.png"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "programAddress": {
    ///      "description": "DEX program address",
    ///      "examples": [
    ///        "whirLbMiicVdio4qvUfM5KAg6Ct8VwpYzGff3uctyCc"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "protocolFamily": {
    ///      "$ref": "#/components/schemas/DexProtocolFamily"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct Dex {
        ///Chain identifier
        pub chain: ::std::string::String,
        ///DEX image URL
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub image: ::std::option::Option<::std::string::String>,
        ///DEX program address
        #[serde(
            rename = "programAddress",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub program_address: ::std::option::Option<::std::string::String>,
        #[serde(
            rename = "protocolFamily",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub protocol_family: ::std::option::Option<DexProtocolFamily>,
    }
    impl ::std::convert::From<&Dex> for Dex {
        fn from(value: &Dex) -> Self {
            value.clone()
        }
    }
    impl Dex {
        pub fn builder() -> builder::Dex {
            Default::default()
        }
    }
    ///DEX pool
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "DEX pool",
    ///  "type": "object",
    ///  "required": [
    ///    "chain",
    ///    "poolAddress",
    ///    "tokenAAddress",
    ///    "tokenBAddress"
    ///  ],
    ///  "properties": {
    ///    "chain": {
    ///      "description": "Chain",
    ///      "examples": [
    ///        "sol"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "poolAddress": {
    ///      "description": "Pool address",
    ///      "examples": [
    ///        "58oQChx4yWmvKdwLLZzBi4ChoCc2fqCUWBkwMihLYQo2"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "programAddress": {
    ///      "description": "DEX program address",
    ///      "examples": [
    ///        "675kPX9MHTjS2zt1qfr1NYHuzeLXfQM9H24wFSUt1Mp8"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "protocolFamily": {
    ///      "description": "Protocol family",
    ///      "examples": [
    ///        "raydium"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "tokenAAddress": {
    ///      "description": "Token A address",
    ///      "examples": [
    ///        "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "tokenBAddress": {
    ///      "description": "Token B address",
    ///      "examples": [
    ///        "So11111111111111111111111111111111111111112"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "tvlInSol": {
    ///      "description": "TVL in native token",
    ///      "examples": [
    ///        "1000000.45"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "tvlInUsd": {
    ///      "description": "TVL in USD",
    ///      "examples": [
    ///        "1000000.45"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct DexPool {
        ///Chain
        pub chain: ::std::string::String,
        ///Pool address
        #[serde(rename = "poolAddress")]
        pub pool_address: ::std::string::String,
        ///DEX program address
        #[serde(
            rename = "programAddress",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub program_address: ::std::option::Option<::std::string::String>,
        ///Protocol family
        #[serde(
            rename = "protocolFamily",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub protocol_family: ::std::option::Option<::std::string::String>,
        ///Token A address
        #[serde(rename = "tokenAAddress")]
        pub token_a_address: ::std::string::String,
        ///Token B address
        #[serde(rename = "tokenBAddress")]
        pub token_b_address: ::std::string::String,
        ///TVL in native token
        #[serde(
            rename = "tvlInSol",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub tvl_in_sol: ::std::option::Option<::std::string::String>,
        ///TVL in USD
        #[serde(
            rename = "tvlInUsd",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub tvl_in_usd: ::std::option::Option<::std::string::String>,
    }
    impl ::std::convert::From<&DexPool> for DexPool {
        fn from(value: &DexPool) -> Self {
            value.clone()
        }
    }
    impl DexPool {
        pub fn builder() -> builder::DexPool {
            Default::default()
        }
    }
    ///DEX pool detail
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "DEX pool detail",
    ///  "examples": [
    ///    {
    ///      "chain": "sol",
    ///      "createdBlockTimestamp": "2024-01-15T10:30:00Z",
    ///      "feeRate": "0.003",
    ///      "image": "https://example.com/pool.png",
    ///      "liquidityModel": 1,
    ///      "poolAddress": "58oQChx4yWmvKdwLLZzBi4ChoCc2fqCUWBkwMihLYQo2",
    ///      "programAddress": "whirLbMiicVdio4qvUfM5KAg6Ct8VwpYzGff3uctyCc",
    ///      "protocolFamily": "OrcaWhirpool",
    ///      "protocolName": "Orca",
    ///      "tickSpacing": 64,
    ///      "tokenAAddress": "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
    ///      "tokenALiquidity": {
    ///        "amountInNative": "5000.123",
    ///        "amountInUsd": "1000000.45",
    ///        "decimals": 6,
    ///        "priceNative": "0.005",
    ///        "priceUsd": "1.0001",
    ///        "tokenAddress": "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
    ///        "vaultAmount": "1000000000000"
    ///      },
    ///      "tokenBAddress": "Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB",
    ///      "tokenBLiquidity": {
    ///        "amountInNative": "5000.123",
    ///        "amountInUsd": "1000000.45",
    ///        "decimals": 6,
    ///        "priceNative": "0.005",
    ///        "priceUsd": "1.0001",
    ///        "tokenAddress": "Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB",
    ///        "vaultAmount": "1000000000000"
    ///      },
    ///      "tokenCount": 2,
    ///      "tvlInSol": "5000",
    ///      "tvlInUsd": "1000000.45",
    ///      "type": 1,
    ///      "version": 2
    ///    }
    ///  ],
    ///  "type": "object",
    ///  "required": [
    ///    "chain",
    ///    "poolAddress",
    ///    "tokenAAddress",
    ///    "tokenBAddress"
    ///  ],
    ///  "properties": {
    ///    "chain": {
    ///      "description": "Chain identifier",
    ///      "type": "string"
    ///    },
    ///    "createdBlockTimestamp": {
    ///      "description": "Creation block timestamp",
    ///      "type": "string"
    ///    },
    ///    "feeRate": {
    ///      "description": "Fee rate",
    ///      "type": "string"
    ///    },
    ///    "image": {
    ///      "description": "Image URL",
    ///      "type": "string"
    ///    },
    ///    "liquidityModel": {
    ///      "description": "Liquidity model",
    ///      "type": "integer",
    ///      "format": "int32",
    ///      "minimum": 0.0
    ///    },
    ///    "poolAddress": {
    ///      "description": "Pool address",
    ///      "type": "string"
    ///    },
    ///    "programAddress": {
    ///      "description": "DEX program address",
    ///      "type": "string"
    ///    },
    ///    "protocolFamily": {
    ///      "description": "Protocol family",
    ///      "type": "string"
    ///    },
    ///    "protocolName": {
    ///      "description": "Protocol name",
    ///      "type": "string"
    ///    },
    ///    "tickSpacing": {
    ///      "description": "Tick spacing",
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "tokenAAddress": {
    ///      "description": "Token A address",
    ///      "type": "string"
    ///    },
    ///    "tokenALiquidity": {
    ///      "$ref": "#/components/schemas/DexPoolTokenLiquidity"
    ///    },
    ///    "tokenBAddress": {
    ///      "description": "Token B address",
    ///      "type": "string"
    ///    },
    ///    "tokenBLiquidity": {
    ///      "$ref": "#/components/schemas/DexPoolTokenLiquidity"
    ///    },
    ///    "tokenCount": {
    ///      "description": "Token count",
    ///      "type": "integer",
    ///      "format": "int32"
    ///    },
    ///    "tvlInSol": {
    ///      "description": "TVL in native token",
    ///      "type": "string"
    ///    },
    ///    "tvlInUsd": {
    ///      "description": "TVL in USD",
    ///      "type": "string"
    ///    },
    ///    "type": {
    ///      "description": "Pool type",
    ///      "type": "integer",
    ///      "format": "int32",
    ///      "minimum": 0.0
    ///    },
    ///    "version": {
    ///      "description": "Pool version",
    ///      "type": "integer",
    ///      "format": "int32",
    ///      "minimum": 0.0
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct DexPoolDetail {
        ///Chain identifier
        pub chain: ::std::string::String,
        ///Creation block timestamp
        #[serde(
            rename = "createdBlockTimestamp",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub created_block_timestamp: ::std::option::Option<::std::string::String>,
        ///Fee rate
        #[serde(
            rename = "feeRate",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub fee_rate: ::std::option::Option<::std::string::String>,
        ///Image URL
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub image: ::std::option::Option<::std::string::String>,
        ///Liquidity model
        #[serde(
            rename = "liquidityModel",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub liquidity_model: ::std::option::Option<i32>,
        ///Pool address
        #[serde(rename = "poolAddress")]
        pub pool_address: ::std::string::String,
        ///DEX program address
        #[serde(
            rename = "programAddress",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub program_address: ::std::option::Option<::std::string::String>,
        ///Protocol family
        #[serde(
            rename = "protocolFamily",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub protocol_family: ::std::option::Option<::std::string::String>,
        ///Protocol name
        #[serde(
            rename = "protocolName",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub protocol_name: ::std::option::Option<::std::string::String>,
        ///Tick spacing
        #[serde(
            rename = "tickSpacing",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub tick_spacing: ::std::option::Option<i64>,
        ///Token A address
        #[serde(rename = "tokenAAddress")]
        pub token_a_address: ::std::string::String,
        #[serde(
            rename = "tokenALiquidity",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub token_a_liquidity: ::std::option::Option<DexPoolTokenLiquidity>,
        ///Token B address
        #[serde(rename = "tokenBAddress")]
        pub token_b_address: ::std::string::String,
        #[serde(
            rename = "tokenBLiquidity",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub token_b_liquidity: ::std::option::Option<DexPoolTokenLiquidity>,
        ///Token count
        #[serde(
            rename = "tokenCount",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub token_count: ::std::option::Option<i32>,
        ///TVL in native token
        #[serde(
            rename = "tvlInSol",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub tvl_in_sol: ::std::option::Option<::std::string::String>,
        ///TVL in USD
        #[serde(
            rename = "tvlInUsd",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub tvl_in_usd: ::std::option::Option<::std::string::String>,
        ///Pool type
        #[serde(
            rename = "type",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub type_: ::std::option::Option<i32>,
        ///Pool version
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub version: ::std::option::Option<i32>,
    }
    impl ::std::convert::From<&DexPoolDetail> for DexPoolDetail {
        fn from(value: &DexPoolDetail) -> Self {
            value.clone()
        }
    }
    impl DexPoolDetail {
        pub fn builder() -> builder::DexPoolDetail {
            Default::default()
        }
    }
    ///DEX pool liquidity model (0=Unknown, 1=ReserveBased, 2=PositionBased, 3=Virtual, 4=Shared)
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "DEX pool liquidity model (0=Unknown, 1=ReserveBased, 2=PositionBased, 3=Virtual, 4=Shared)",
    ///  "examples": [
    ///    1
    ///  ],
    ///  "type": "string",
    ///  "enum": [
    ///    "Unknown",
    ///    "ReserveBased",
    ///    "PositionBased",
    ///    "Virtual",
    ///    "Shared"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum DexPoolLiquidityModel {
        Unknown,
        ReserveBased,
        PositionBased,
        Virtual,
        Shared,
    }
    impl ::std::convert::From<&Self> for DexPoolLiquidityModel {
        fn from(value: &DexPoolLiquidityModel) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for DexPoolLiquidityModel {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::Unknown => f.write_str("Unknown"),
                Self::ReserveBased => f.write_str("ReserveBased"),
                Self::PositionBased => f.write_str("PositionBased"),
                Self::Virtual => f.write_str("Virtual"),
                Self::Shared => f.write_str("Shared"),
            }
        }
    }
    impl ::std::str::FromStr for DexPoolLiquidityModel {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "Unknown" => Ok(Self::Unknown),
                "ReserveBased" => Ok(Self::ReserveBased),
                "PositionBased" => Ok(Self::PositionBased),
                "Virtual" => Ok(Self::Virtual),
                "Shared" => Ok(Self::Shared),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for DexPoolLiquidityModel {
        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 DexPoolLiquidityModel {
        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 DexPoolLiquidityModel {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    ///DEX pool liquidity snapshot
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "DEX pool liquidity snapshot",
    ///  "examples": [
    ///    {
    ///      "blockHeight": 123456789,
    ///      "blockSlot": 123456789,
    ///      "blockTimestamp": 1705312800000,
    ///      "poolAddress": "58oQChx4yWmvKdwLLZzBi4ChoCc2fqCUWBkwMihLYQo2",
    ///      "snapshotTime": 1705312800000,
    ///      "tokenA": {
    ///        "amountInNative": "5000.123",
    ///        "amountInUsd": "1000000.45",
    ///        "decimals": 6,
    ///        "priceNative": "0.005",
    ///        "priceUsd": "1.0001",
    ///        "tokenAddress": "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
    ///        "vaultAmount": "1000000000000"
    ///      },
    ///      "tokenB": {
    ///        "amountInNative": "5000.123",
    ///        "amountInUsd": "1000000.45",
    ///        "decimals": 6,
    ///        "priceNative": "0.005",
    ///        "priceUsd": "1.0001",
    ///        "tokenAddress": "Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB",
    ///        "vaultAmount": "1000000000000"
    ///      },
    ///      "tvlInNative": "5000",
    ///      "tvlInUsd": "1000000.45"
    ///    }
    ///  ],
    ///  "type": "object",
    ///  "required": [
    ///    "blockHeight",
    ///    "blockTimestamp",
    ///    "poolAddress",
    ///    "snapshotTime",
    ///    "tokenA",
    ///    "tokenB",
    ///    "tvlInNative",
    ///    "tvlInUsd"
    ///  ],
    ///  "properties": {
    ///    "blockHeight": {
    ///      "description": "Block height",
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "blockSlot": {
    ///      "description": "Block slot (optional)",
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "blockTimestamp": {
    ///      "description": "Block timestamp (ms)",
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "poolAddress": {
    ///      "description": "Pool address",
    ///      "type": "string"
    ///    },
    ///    "snapshotTime": {
    ///      "description": "Snapshot timestamp (ms)",
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "tokenA": {
    ///      "$ref": "#/components/schemas/DexPoolTokenSnapshot"
    ///    },
    ///    "tokenB": {
    ///      "$ref": "#/components/schemas/DexPoolTokenSnapshot"
    ///    },
    ///    "tvlInNative": {
    ///      "description": "TVL in native token",
    ///      "type": "string"
    ///    },
    ///    "tvlInUsd": {
    ///      "description": "TVL in USD",
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct DexPoolSnapshot {
        ///Block height
        #[serde(rename = "blockHeight")]
        pub block_height: i64,
        ///Block slot (optional)
        #[serde(
            rename = "blockSlot",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub block_slot: ::std::option::Option<i64>,
        ///Block timestamp (ms)
        #[serde(rename = "blockTimestamp")]
        pub block_timestamp: i64,
        ///Pool address
        #[serde(rename = "poolAddress")]
        pub pool_address: ::std::string::String,
        ///Snapshot timestamp (ms)
        #[serde(rename = "snapshotTime")]
        pub snapshot_time: i64,
        #[serde(rename = "tokenA")]
        pub token_a: DexPoolTokenSnapshot,
        #[serde(rename = "tokenB")]
        pub token_b: DexPoolTokenSnapshot,
        ///TVL in native token
        #[serde(rename = "tvlInNative")]
        pub tvl_in_native: ::std::string::String,
        ///TVL in USD
        #[serde(rename = "tvlInUsd")]
        pub tvl_in_usd: ::std::string::String,
    }
    impl ::std::convert::From<&DexPoolSnapshot> for DexPoolSnapshot {
        fn from(value: &DexPoolSnapshot) -> Self {
            value.clone()
        }
    }
    impl DexPoolSnapshot {
        pub fn builder() -> builder::DexPoolSnapshot {
            Default::default()
        }
    }
    ///DEX pool token liquidity
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "DEX pool token liquidity",
    ///  "type": "object",
    ///  "required": [
    ///    "amountInNative",
    ///    "amountInUsd",
    ///    "decimals",
    ///    "priceNative",
    ///    "priceUsd",
    ///    "tokenAddress",
    ///    "vaultAmount"
    ///  ],
    ///  "properties": {
    ///    "amountInNative": {
    ///      "description": "Amount in native token",
    ///      "examples": [
    ///        "5000.123"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "amountInUsd": {
    ///      "description": "Amount in USD",
    ///      "examples": [
    ///        "1000000.45"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "decimals": {
    ///      "description": "Token decimals",
    ///      "examples": [
    ///        6
    ///      ],
    ///      "type": "integer",
    ///      "format": "int32"
    ///    },
    ///    "priceNative": {
    ///      "description": "Price in native token",
    ///      "examples": [
    ///        "0.005"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "priceUsd": {
    ///      "description": "Price in USD",
    ///      "examples": [
    ///        "1.0001"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "tokenAddress": {
    ///      "description": "Token address",
    ///      "examples": [
    ///        "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "vaultAmount": {
    ///      "description": "Vault amount",
    ///      "examples": [
    ///        "1000000000000"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct DexPoolTokenLiquidity {
        ///Amount in native token
        #[serde(rename = "amountInNative")]
        pub amount_in_native: ::std::string::String,
        ///Amount in USD
        #[serde(rename = "amountInUsd")]
        pub amount_in_usd: ::std::string::String,
        ///Token decimals
        pub decimals: i32,
        ///Price in native token
        #[serde(rename = "priceNative")]
        pub price_native: ::std::string::String,
        ///Price in USD
        #[serde(rename = "priceUsd")]
        pub price_usd: ::std::string::String,
        ///Token address
        #[serde(rename = "tokenAddress")]
        pub token_address: ::std::string::String,
        ///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()
        }
    }
    ///DEX pool token snapshot
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "DEX pool token snapshot",
    ///  "type": "object",
    ///  "required": [
    ///    "amountInNative",
    ///    "amountInUsd",
    ///    "decimals",
    ///    "priceNative",
    ///    "priceUsd",
    ///    "tokenAddress",
    ///    "vaultAmount"
    ///  ],
    ///  "properties": {
    ///    "amountInNative": {
    ///      "description": "Amount in native token",
    ///      "examples": [
    ///        "5000.123"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "amountInUsd": {
    ///      "description": "Amount in USD",
    ///      "examples": [
    ///        "1000000.45"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "decimals": {
    ///      "description": "Token decimals",
    ///      "examples": [
    ///        6
    ///      ],
    ///      "type": "integer",
    ///      "format": "int32"
    ///    },
    ///    "priceNative": {
    ///      "description": "Price in native token",
    ///      "examples": [
    ///        "0.005"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "priceUsd": {
    ///      "description": "Price in USD",
    ///      "examples": [
    ///        "1.0001"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "tokenAddress": {
    ///      "description": "Token address",
    ///      "examples": [
    ///        "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "vaultAmount": {
    ///      "description": "Vault amount",
    ///      "examples": [
    ///        "1000000000000"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct DexPoolTokenSnapshot {
        ///Amount in native token
        #[serde(rename = "amountInNative")]
        pub amount_in_native: ::std::string::String,
        ///Amount in USD
        #[serde(rename = "amountInUsd")]
        pub amount_in_usd: ::std::string::String,
        ///Token decimals
        pub decimals: i32,
        ///Price in native token
        #[serde(rename = "priceNative")]
        pub price_native: ::std::string::String,
        ///Price in USD
        #[serde(rename = "priceUsd")]
        pub price_usd: ::std::string::String,
        ///Token address
        #[serde(rename = "tokenAddress")]
        pub token_address: ::std::string::String,
        ///Vault amount
        #[serde(rename = "vaultAmount")]
        pub vault_amount: ::std::string::String,
    }
    impl ::std::convert::From<&DexPoolTokenSnapshot> for DexPoolTokenSnapshot {
        fn from(value: &DexPoolTokenSnapshot) -> Self {
            value.clone()
        }
    }
    impl DexPoolTokenSnapshot {
        pub fn builder() -> builder::DexPoolTokenSnapshot {
            Default::default()
        }
    }
    ///DEX pool type (0=Unknown, 1=Standard, 2=Concentrated, 3=Weighted, 4=Stable)
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "DEX pool type (0=Unknown, 1=Standard, 2=Concentrated, 3=Weighted, 4=Stable)",
    ///  "examples": [
    ///    1
    ///  ],
    ///  "type": "string",
    ///  "enum": [
    ///    "Unknown",
    ///    "Standard",
    ///    "Concentrated",
    ///    "Weighted",
    ///    "Stable"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum DexPoolType {
        Unknown,
        Standard,
        Concentrated,
        Weighted,
        Stable,
    }
    impl ::std::convert::From<&Self> for DexPoolType {
        fn from(value: &DexPoolType) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for DexPoolType {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::Unknown => f.write_str("Unknown"),
                Self::Standard => f.write_str("Standard"),
                Self::Concentrated => f.write_str("Concentrated"),
                Self::Weighted => f.write_str("Weighted"),
                Self::Stable => f.write_str("Stable"),
            }
        }
    }
    impl ::std::str::FromStr for DexPoolType {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "Unknown" => Ok(Self::Unknown),
                "Standard" => Ok(Self::Standard),
                "Concentrated" => Ok(Self::Concentrated),
                "Weighted" => Ok(Self::Weighted),
                "Stable" => Ok(Self::Stable),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for DexPoolType {
        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 DexPoolType {
        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 DexPoolType {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    ///DEX pool version (0=Unknown, 1=V1, 2=V2, 3=V3)
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "DEX pool version (0=Unknown, 1=V1, 2=V2, 3=V3)",
    ///  "examples": [
    ///    2
    ///  ],
    ///  "type": "string",
    ///  "enum": [
    ///    "Unknown",
    ///    "V1",
    ///    "V2",
    ///    "V3"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum DexPoolVersion {
        Unknown,
        V1,
        V2,
        V3,
    }
    impl ::std::convert::From<&Self> for DexPoolVersion {
        fn from(value: &DexPoolVersion) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for DexPoolVersion {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::Unknown => f.write_str("Unknown"),
                Self::V1 => f.write_str("V1"),
                Self::V2 => f.write_str("V2"),
                Self::V3 => f.write_str("V3"),
            }
        }
    }
    impl ::std::str::FromStr for DexPoolVersion {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "Unknown" => Ok(Self::Unknown),
                "V1" => Ok(Self::V1),
                "V2" => Ok(Self::V2),
                "V3" => Ok(Self::V3),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for DexPoolVersion {
        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 DexPoolVersion {
        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 DexPoolVersion {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    ///DEX protocol family identifier
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "DEX protocol family identifier",
    ///  "type": "string",
    ///  "enum": [
    ///    "Raydium",
    ///    "Pumpfun",
    ///    "Pumpswap",
    ///    "Meteora",
    ///    "Moonshot",
    ///    "Jupiter",
    ///    "Orca",
    ///    "OrcaWhirpool",
    ///    "OpenBook",
    ///    "Phoenix",
    ///    "Lifinity",
    ///    "MagicEden",
    ///    "Tensor",
    ///    "Aldrin",
    ///    "AldrinAmm",
    ///    "BonkFun",
    ///    "BoopFun",
    ///    "CremaFinance",
    ///    "Cropper",
    ///    "Cykura",
    ///    "Dradex",
    ///    "Fluxbeam",
    ///    "GooseFx",
    ///    "Invariant",
    ///    "Intro",
    ///    "Metaplex",
    ///    "OasisProgram",
    ///    "Obric",
    ///    "PancakeClmm",
    ///    "Penguin",
    ///    "Saber",
    ///    "Saros",
    ///    "Sencha",
    ///    "Sentre",
    ///    "Serum",
    ///    "Solana",
    ///    "SolFi",
    ///    "Stabble",
    ///    "StepFinance",
    ///    "StepN",
    ///    "Symmetry",
    ///    "ZeroFi",
    ///    "Unknown"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum DexProtocolFamily {
        Raydium,
        Pumpfun,
        Pumpswap,
        Meteora,
        Moonshot,
        Jupiter,
        Orca,
        OrcaWhirpool,
        OpenBook,
        Phoenix,
        Lifinity,
        MagicEden,
        Tensor,
        Aldrin,
        AldrinAmm,
        BonkFun,
        BoopFun,
        CremaFinance,
        Cropper,
        Cykura,
        Dradex,
        Fluxbeam,
        GooseFx,
        Invariant,
        Intro,
        Metaplex,
        OasisProgram,
        Obric,
        PancakeClmm,
        Penguin,
        Saber,
        Saros,
        Sencha,
        Sentre,
        Serum,
        Solana,
        SolFi,
        Stabble,
        StepFinance,
        StepN,
        Symmetry,
        ZeroFi,
        Unknown,
    }
    impl ::std::convert::From<&Self> for DexProtocolFamily {
        fn from(value: &DexProtocolFamily) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for DexProtocolFamily {
        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::Pumpswap => f.write_str("Pumpswap"),
                Self::Meteora => f.write_str("Meteora"),
                Self::Moonshot => f.write_str("Moonshot"),
                Self::Jupiter => f.write_str("Jupiter"),
                Self::Orca => f.write_str("Orca"),
                Self::OrcaWhirpool => f.write_str("OrcaWhirpool"),
                Self::OpenBook => f.write_str("OpenBook"),
                Self::Phoenix => f.write_str("Phoenix"),
                Self::Lifinity => f.write_str("Lifinity"),
                Self::MagicEden => f.write_str("MagicEden"),
                Self::Tensor => f.write_str("Tensor"),
                Self::Aldrin => f.write_str("Aldrin"),
                Self::AldrinAmm => f.write_str("AldrinAmm"),
                Self::BonkFun => f.write_str("BonkFun"),
                Self::BoopFun => f.write_str("BoopFun"),
                Self::CremaFinance => f.write_str("CremaFinance"),
                Self::Cropper => f.write_str("Cropper"),
                Self::Cykura => f.write_str("Cykura"),
                Self::Dradex => f.write_str("Dradex"),
                Self::Fluxbeam => f.write_str("Fluxbeam"),
                Self::GooseFx => f.write_str("GooseFx"),
                Self::Invariant => f.write_str("Invariant"),
                Self::Intro => f.write_str("Intro"),
                Self::Metaplex => f.write_str("Metaplex"),
                Self::OasisProgram => f.write_str("OasisProgram"),
                Self::Obric => f.write_str("Obric"),
                Self::PancakeClmm => f.write_str("PancakeClmm"),
                Self::Penguin => f.write_str("Penguin"),
                Self::Saber => f.write_str("Saber"),
                Self::Saros => f.write_str("Saros"),
                Self::Sencha => f.write_str("Sencha"),
                Self::Sentre => f.write_str("Sentre"),
                Self::Serum => f.write_str("Serum"),
                Self::Solana => f.write_str("Solana"),
                Self::SolFi => f.write_str("SolFi"),
                Self::Stabble => f.write_str("Stabble"),
                Self::StepFinance => f.write_str("StepFinance"),
                Self::StepN => f.write_str("StepN"),
                Self::Symmetry => f.write_str("Symmetry"),
                Self::ZeroFi => f.write_str("ZeroFi"),
                Self::Unknown => f.write_str("Unknown"),
            }
        }
    }
    impl ::std::str::FromStr for DexProtocolFamily {
        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),
                "Pumpswap" => Ok(Self::Pumpswap),
                "Meteora" => Ok(Self::Meteora),
                "Moonshot" => Ok(Self::Moonshot),
                "Jupiter" => Ok(Self::Jupiter),
                "Orca" => Ok(Self::Orca),
                "OrcaWhirpool" => Ok(Self::OrcaWhirpool),
                "OpenBook" => Ok(Self::OpenBook),
                "Phoenix" => Ok(Self::Phoenix),
                "Lifinity" => Ok(Self::Lifinity),
                "MagicEden" => Ok(Self::MagicEden),
                "Tensor" => Ok(Self::Tensor),
                "Aldrin" => Ok(Self::Aldrin),
                "AldrinAmm" => Ok(Self::AldrinAmm),
                "BonkFun" => Ok(Self::BonkFun),
                "BoopFun" => Ok(Self::BoopFun),
                "CremaFinance" => Ok(Self::CremaFinance),
                "Cropper" => Ok(Self::Cropper),
                "Cykura" => Ok(Self::Cykura),
                "Dradex" => Ok(Self::Dradex),
                "Fluxbeam" => Ok(Self::Fluxbeam),
                "GooseFx" => Ok(Self::GooseFx),
                "Invariant" => Ok(Self::Invariant),
                "Intro" => Ok(Self::Intro),
                "Metaplex" => Ok(Self::Metaplex),
                "OasisProgram" => Ok(Self::OasisProgram),
                "Obric" => Ok(Self::Obric),
                "PancakeClmm" => Ok(Self::PancakeClmm),
                "Penguin" => Ok(Self::Penguin),
                "Saber" => Ok(Self::Saber),
                "Saros" => Ok(Self::Saros),
                "Sencha" => Ok(Self::Sencha),
                "Sentre" => Ok(Self::Sentre),
                "Serum" => Ok(Self::Serum),
                "Solana" => Ok(Self::Solana),
                "SolFi" => Ok(Self::SolFi),
                "Stabble" => Ok(Self::Stabble),
                "StepFinance" => Ok(Self::StepFinance),
                "StepN" => Ok(Self::StepN),
                "Symmetry" => Ok(Self::Symmetry),
                "ZeroFi" => Ok(Self::ZeroFi),
                "Unknown" => Ok(Self::Unknown),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for DexProtocolFamily {
        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 DexProtocolFamily {
        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 DexProtocolFamily {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    ///`DexQuoteResponse`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "properties": {
    ///    "amountOut": {
    ///      "description": "Output amount",
    ///      "examples": [
    ///        "1000000000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "currentPrice": {
    ///      "description": "Current price",
    ///      "type": "string"
    ///    },
    ///    "executionPrice": {
    ///      "description": "Execution price",
    ///      "type": "string"
    ///    },
    ///    "fee": {
    ///      "description": "Trading fee",
    ///      "examples": [
    ///        "1000000000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "minAmountOut": {
    ///      "description": "Minimum output amount",
    ///      "type": "string"
    ///    },
    ///    "priceImpact": {
    ///      "description": "Price impact",
    ///      "examples": [
    ///        "10.5"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct DexQuoteResponse {
        ///Output amount
        #[serde(
            rename = "amountOut",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub amount_out: ::std::option::Option<::std::string::String>,
        ///Current price
        #[serde(
            rename = "currentPrice",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub current_price: ::std::option::Option<::std::string::String>,
        ///Execution price
        #[serde(
            rename = "executionPrice",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub execution_price: ::std::option::Option<::std::string::String>,
        ///Trading fee
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub fee: ::std::option::Option<::std::string::String>,
        ///Minimum output amount
        #[serde(
            rename = "minAmountOut",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub min_amount_out: ::std::option::Option<::std::string::String>,
        ///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()
        }
    }
    ///`DexscrAd`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "chain",
    ///    "tokenAddress"
    ///  ],
    ///  "properties": {
    ///    "adType": {
    ///      "description": "Ad type (e.g. banner)",
    ///      "type": "string"
    ///    },
    ///    "chain": {
    ///      "description": "Blockchain network identifier",
    ///      "examples": [
    ///        "sol"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "date": {
    ///      "description": "Ad start date",
    ///      "type": "string"
    ///    },
    ///    "durationHours": {
    ///      "description": "Ad duration in hours",
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "impressions": {
    ///      "description": "Total ad impressions count",
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "tokenAddress": {
    ///      "description": "Token contract address",
    ///      "examples": [
    ///        "So11111111111111111111111111111111111111112"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "url": {
    ///      "description": "DexScreener token page URL",
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct DexscrAd {
        ///Ad type (e.g. banner)
        #[serde(
            rename = "adType",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub ad_type: ::std::option::Option<::std::string::String>,
        ///Blockchain network identifier
        pub chain: ::std::string::String,
        ///Ad start date
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub date: ::std::option::Option<::std::string::String>,
        ///Ad duration in hours
        #[serde(
            rename = "durationHours",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub duration_hours: ::std::option::Option<i64>,
        ///Total ad impressions count
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub impressions: ::std::option::Option<i64>,
        ///Token contract address
        #[serde(rename = "tokenAddress")]
        pub token_address: ::std::string::String,
        ///DexScreener token page URL
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub url: ::std::option::Option<::std::string::String>,
    }
    impl ::std::convert::From<&DexscrAd> for DexscrAd {
        fn from(value: &DexscrAd) -> Self {
            value.clone()
        }
    }
    impl DexscrAd {
        pub fn builder() -> builder::DexscrAd {
            Default::default()
        }
    }
    ///`DexscrBoost`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "chain",
    ///    "tokenAddress",
    ///    "totalAmount"
    ///  ],
    ///  "properties": {
    ///    "amount": {
    ///      "description": "Current boost amount",
    ///      "type": "number",
    ///      "format": "double"
    ///    },
    ///    "chain": {
    ///      "description": "Blockchain network identifier",
    ///      "examples": [
    ///        "sol"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "description": {
    ///      "description": "Token description",
    ///      "type": "string"
    ///    },
    ///    "header": {
    ///      "description": "Token header image URL",
    ///      "type": "string"
    ///    },
    ///    "icon": {
    ///      "description": "Token icon URL",
    ///      "type": "string"
    ///    },
    ///    "links": {
    ///      "description": "Token social links in JSON format"
    ///    },
    ///    "openGraph": {
    ///      "description": "Token Open Graph image URL",
    ///      "type": "string"
    ///    },
    ///    "tokenAddress": {
    ///      "description": "Token contract address",
    ///      "examples": [
    ///        "So11111111111111111111111111111111111111112"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "totalAmount": {
    ///      "description": "Total boost amount spent",
    ///      "examples": [
    ///        500
    ///      ],
    ///      "type": "number",
    ///      "format": "double"
    ///    },
    ///    "url": {
    ///      "description": "DexScreener token page URL",
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct DexscrBoost {
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub amount: ::std::option::Option<f64>,
        ///Blockchain network identifier
        pub chain: ::std::string::String,
        ///Token description
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub description: ::std::option::Option<::std::string::String>,
        ///Token header image URL
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub header: ::std::option::Option<::std::string::String>,
        ///Token icon URL
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub icon: ::std::option::Option<::std::string::String>,
        ///Token social links in JSON format
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub links: ::std::option::Option<::serde_json::Value>,
        ///Token Open Graph image URL
        #[serde(
            rename = "openGraph",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub open_graph: ::std::option::Option<::std::string::String>,
        ///Token contract address
        #[serde(rename = "tokenAddress")]
        pub token_address: ::std::string::String,
        #[serde(rename = "totalAmount")]
        pub total_amount: f64,
        ///DexScreener token page URL
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub url: ::std::option::Option<::std::string::String>,
    }
    impl ::std::convert::From<&DexscrBoost> for DexscrBoost {
        fn from(value: &DexscrBoost) -> Self {
            value.clone()
        }
    }
    impl DexscrBoost {
        pub fn builder() -> builder::DexscrBoost {
            Default::default()
        }
    }
    ///`DexscrLinkUpdate`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "chain",
    ///    "tokenAddress"
    ///  ],
    ///  "properties": {
    ///    "chain": {
    ///      "description": "Blockchain network identifier",
    ///      "examples": [
    ///        "sol"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "description": {
    ///      "description": "Token description",
    ///      "type": "string"
    ///    },
    ///    "header": {
    ///      "description": "Token header image URL",
    ///      "type": "string"
    ///    },
    ///    "icon": {
    ///      "description": "Token icon URL",
    ///      "type": "string"
    ///    },
    ///    "links": {
    ///      "description": "Token social links in JSON format"
    ///    },
    ///    "openGraph": {
    ///      "description": "Token Open Graph image URL",
    ///      "type": "string"
    ///    },
    ///    "tokenAddress": {
    ///      "description": "Token contract address",
    ///      "examples": [
    ///        "So11111111111111111111111111111111111111112"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "url": {
    ///      "description": "DexScreener token page URL",
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct DexscrLinkUpdate {
        ///Blockchain network identifier
        pub chain: ::std::string::String,
        ///Token description
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub description: ::std::option::Option<::std::string::String>,
        ///Token header image URL
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub header: ::std::option::Option<::std::string::String>,
        ///Token icon URL
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub icon: ::std::option::Option<::std::string::String>,
        ///Token social links in JSON format
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub links: ::std::option::Option<::serde_json::Value>,
        ///Token Open Graph image URL
        #[serde(
            rename = "openGraph",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub open_graph: ::std::option::Option<::std::string::String>,
        ///Token contract address
        #[serde(rename = "tokenAddress")]
        pub token_address: ::std::string::String,
        ///DexScreener token page URL
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub url: ::std::option::Option<::std::string::String>,
    }
    impl ::std::convert::From<&DexscrLinkUpdate> for DexscrLinkUpdate {
        fn from(value: &DexscrLinkUpdate) -> Self {
            value.clone()
        }
    }
    impl DexscrLinkUpdate {
        pub fn builder() -> builder::DexscrLinkUpdate {
            Default::default()
        }
    }
    ///Per-token aggregated DexScreener information.
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Per-token aggregated DexScreener information.",
    ///  "type": "object",
    ///  "required": [
    ///    "chain",
    ///    "tokenAddress"
    ///  ],
    ///  "properties": {
    ///    "ad": {
    ///      "$ref": "#/components/schemas/DexscrAd"
    ///    },
    ///    "boost": {
    ///      "$ref": "#/components/schemas/DexscrBoost"
    ///    },
    ///    "chain": {
    ///      "description": "Blockchain network identifier",
    ///      "examples": [
    ///        "sol"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "linkUpdate": {
    ///      "$ref": "#/components/schemas/DexscrLinkUpdate"
    ///    },
    ///    "tokenAddress": {
    ///      "description": "Token contract address",
    ///      "examples": [
    ///        "WCoRVxGcpiwE6EvtDjXHJq6Kcn4nWT9Ubt1PrJHNAzM"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct DexscrTokenInfo {
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub ad: ::std::option::Option<DexscrAd>,
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub boost: ::std::option::Option<DexscrBoost>,
        ///Blockchain network identifier
        pub chain: ::std::string::String,
        #[serde(
            rename = "linkUpdate",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub link_update: ::std::option::Option<DexscrLinkUpdate>,
        ///Token contract address
        #[serde(rename = "tokenAddress")]
        pub token_address: ::std::string::String,
    }
    impl ::std::convert::From<&DexscrTokenInfo> for DexscrTokenInfo {
        fn from(value: &DexscrTokenInfo) -> Self {
            value.clone()
        }
    }
    impl DexscrTokenInfo {
        pub fn builder() -> builder::DexscrTokenInfo {
            Default::default()
        }
    }
    ///`DexscrTrendingMeta`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "slug"
    ///  ],
    ///  "properties": {
    ///    "description": {
    ///      "description": "Meta category description",
    ///      "type": "string"
    ///    },
    ///    "iconType": {
    ///      "description": "Icon type (e.g. image)",
    ///      "type": "string"
    ///    },
    ///    "iconValue": {
    ///      "description": "Icon URL or identifier value",
    ///      "type": "string"
    ///    },
    ///    "liquidity": {
    ///      "description": "Aggregate liquidity in USD",
    ///      "type": "number",
    ///      "format": "double"
    ///    },
    ///    "marketCap": {
    ///      "description": "Aggregate market capitalization in USD",
    ///      "type": "number",
    ///      "format": "double"
    ///    },
    ///    "marketCapChange": {
    ///      "description": "Market cap change percentages by period in JSON format"
    ///    },
    ///    "name": {
    ///      "description": "Meta category display name",
    ///      "type": "string"
    ///    },
    ///    "slug": {
    ///      "description": "Meta category slug identifier",
    ///      "examples": [
    ///        "ai"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "tokenCount": {
    ///      "description": "Number of tokens in this meta category",
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "volume": {
    ///      "description": "Aggregate trading volume in USD",
    ///      "type": "number",
    ///      "format": "double"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct DexscrTrendingMeta {
        ///Meta category description
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub description: ::std::option::Option<::std::string::String>,
        ///Icon type (e.g. image)
        #[serde(
            rename = "iconType",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub icon_type: ::std::option::Option<::std::string::String>,
        ///Icon URL or identifier value
        #[serde(
            rename = "iconValue",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub icon_value: ::std::option::Option<::std::string::String>,
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub liquidity: ::std::option::Option<f64>,
        #[serde(
            rename = "marketCap",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub market_cap: ::std::option::Option<f64>,
        ///Market cap change percentages by period in JSON format
        #[serde(
            rename = "marketCapChange",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub market_cap_change: ::std::option::Option<::serde_json::Value>,
        ///Meta category display name
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub name: ::std::option::Option<::std::string::String>,
        ///Meta category slug identifier
        pub slug: ::std::string::String,
        ///Number of tokens in this meta category
        #[serde(
            rename = "tokenCount",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub token_count: ::std::option::Option<i64>,
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub volume: ::std::option::Option<f64>,
    }
    impl ::std::convert::From<&DexscrTrendingMeta> for DexscrTrendingMeta {
        fn from(value: &DexscrTrendingMeta) -> Self {
            value.clone()
        }
    }
    impl DexscrTrendingMeta {
        pub fn builder() -> builder::DexscrTrendingMeta {
            Default::default()
        }
    }
    ///Paginated list of webhook endpoints
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Paginated list of webhook endpoints",
    ///  "type": "object",
    ///  "required": [
    ///    "data",
    ///    "done"
    ///  ],
    ///  "properties": {
    ///    "data": {
    ///      "description": "Paginated endpoint list",
    ///      "type": "array",
    ///      "items": {
    ///        "$ref": "#/components/schemas/WebhookEndpoint"
    ///      }
    ///    },
    ///    "done": {
    ///      "description": "Whether pagination is complete",
    ///      "examples": [
    ///        false
    ///      ],
    ///      "type": "boolean"
    ///    },
    ///    "iterator": {
    ///      "description": "Current page iterator",
    ///      "examples": [
    ///        "eyJpZCI6MTAwfQ=="
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "prevIterator": {
    ///      "description": "Previous page iterator",
    ///      "examples": [
    ///        "eyJpZCI6MTAwfQ=="
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct EndpointListResponse {
        ///Paginated endpoint list
        pub data: ::std::vec::Vec<WebhookEndpoint>,
        ///Whether pagination is complete
        pub done: bool,
        ///Current page iterator
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub iterator: ::std::option::Option<::std::string::String>,
        ///Previous page 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 EndpointListResponse {
        pub fn builder() -> builder::EndpointListResponse {
            Default::default()
        }
    }
    ///Boolean result for endpoint operations (delete, rotate secret)
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Boolean result for endpoint operations (delete, rotate secret)",
    ///  "type": "object",
    ///  "required": [
    ///    "success"
    ///  ],
    ///  "properties": {
    ///    "success": {
    ///      "description": "Operation success status",
    ///      "examples": [
    ///        true
    ///      ],
    ///      "type": "boolean"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct EndpointOperationResponse {
        ///Operation success status
        pub success: bool,
    }
    impl ::std::convert::From<&EndpointOperationResponse> for EndpointOperationResponse {
        fn from(value: &EndpointOperationResponse) -> Self {
            value.clone()
        }
    }
    impl EndpointOperationResponse {
        pub fn builder() -> builder::EndpointOperationResponse {
            Default::default()
        }
    }
    ///Ordering direction for paginated endpoint listing
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Ordering direction for paginated endpoint listing",
    ///  "type": "string",
    ///  "enum": [
    ///    "ascending",
    ///    "descending"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum EndpointOrder {
        #[serde(rename = "ascending")]
        Ascending,
        #[serde(rename = "descending")]
        Descending,
    }
    impl ::std::convert::From<&Self> for EndpointOrder {
        fn from(value: &EndpointOrder) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for EndpointOrder {
        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 EndpointOrder {
        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 EndpointOrder {
        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 EndpointOrder {
        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 EndpointOrder {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    ///Secret response for a webhook endpoint
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Secret response for a webhook endpoint",
    ///  "type": "object",
    ///  "required": [
    ///    "secret"
    ///  ],
    ///  "properties": {
    ///    "secret": {
    ///      "description": "Endpoint signing secret",
    ///      "examples": [
    ///        "whsec_abcdXXX"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct EndpointSecretResponse {
        ///Endpoint signing secret
        pub secret: ::std::string::String,
    }
    impl ::std::convert::From<&EndpointSecretResponse> for EndpointSecretResponse {
        fn from(value: &EndpointSecretResponse) -> Self {
            value.clone()
        }
    }
    impl EndpointSecretResponse {
        pub fn builder() -> builder::EndpointSecretResponse {
            Default::default()
        }
    }
    ///`ErrorDetail`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "code",
    ///    "message"
    ///  ],
    ///  "properties": {
    ///    "code": {
    ///      "description": "Error code",
    ///      "examples": [
    ///        40005
    ///      ],
    ///      "type": "integer",
    ///      "format": "int32",
    ///      "minimum": 0.0
    ///    },
    ///    "details": {
    ///      "description": "List of field-level error details",
    ///      "type": "array",
    ///      "items": {
    ///        "$ref": "#/components/schemas/ErrorField"
    ///      }
    ///    },
    ///    "message": {
    ///      "description": "Error message",
    ///      "examples": [
    ///        "Invalid wallet address format"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct ErrorDetail {
        ///Error code
        pub code: i32,
        ///List of field-level error details
        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
        pub details: ::std::vec::Vec<ErrorField>,
        ///Error message
        pub message: ::std::string::String,
    }
    impl ::std::convert::From<&ErrorDetail> for ErrorDetail {
        fn from(value: &ErrorDetail) -> Self {
            value.clone()
        }
    }
    impl ErrorDetail {
        pub fn builder() -> builder::ErrorDetail {
            Default::default()
        }
    }
    ///`ErrorField`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "field",
    ///    "message"
    ///  ],
    ///  "properties": {
    ///    "field": {
    ///      "description": "Field name that caused the error",
    ///      "examples": [
    ///        "walletAddress"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "message": {
    ///      "description": "Error message for the field",
    ///      "examples": [
    ///        "Invalid wallet address format"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct ErrorField {
        ///Field name that caused the error
        pub field: ::std::string::String,
        ///Error message for the field
        pub message: ::std::string::String,
    }
    impl ::std::convert::From<&ErrorField> for ErrorField {
        fn from(value: &ErrorField) -> Self {
            value.clone()
        }
    }
    impl ErrorField {
        pub fn builder() -> builder::ErrorField {
            Default::default()
        }
    }
    ///`ErrorResponse`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "error"
    ///  ],
    ///  "properties": {
    ///    "error": {
    ///      "$ref": "#/components/schemas/ErrorDetail"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct ErrorResponse {
        pub error: ErrorDetail,
    }
    impl ::std::convert::From<&ErrorResponse> for ErrorResponse {
        fn from(value: &ErrorResponse) -> Self {
            value.clone()
        }
    }
    impl ErrorResponse {
        pub fn builder() -> builder::ErrorResponse {
            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()
        }
    }
    ///Filter condition for token queries
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Filter condition for token queries",
    ///  "type": "object",
    ///  "required": [
    ///    "field",
    ///    "operator",
    ///    "value"
    ///  ],
    ///  "properties": {
    ///    "field": {
    ///      "description": "Field name to filter",
    ///      "type": "string"
    ///    },
    ///    "operator": {
    ///      "description": "Operator (gt, gte, lt, lte, eq, ne)",
    ///      "type": "string"
    ///    },
    ///    "value": {
    ///      "description": "Value to compare",
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct FilterCondition {
        ///Field name to filter
        pub field: ::std::string::String,
        ///Operator (gt, gte, lt, lte, eq, ne)
        pub operator: ::std::string::String,
        ///Value to compare
        pub value: ::std::string::String,
    }
    impl ::std::convert::From<&FilterCondition> for FilterCondition {
        fn from(value: &FilterCondition) -> Self {
            value.clone()
        }
    }
    impl FilterCondition {
        pub fn builder() -> builder::FilterCondition {
            Default::default()
        }
    }
    ///`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()
        }
    }
    ///`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()
        }
    }
    ///Token market data
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Token market data",
    ///  "type": "object",
    ///  "properties": {
    ///    "athMarketCapInUsd": {
    ///      "description": "ENTITY.TOKEN_MARKET_DATA.ATH_MARKET_CAP_IN_USD\nAll-time-high market cap in USD (max observed since token creation).",
    ///      "examples": [
    ///        "9500000.00"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "bluechipHoldingsRatio": {
    ///      "description": "Ratio of bluechip holdings to total supply",
    ///      "examples": [
    ///        "0.05"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "bluechipTotalHolders": {
    ///      "description": "Number of bluechip wallet holders",
    ///      "examples": [
    ///        "10"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "bluechipTotalHoldings": {
    ///      "description": "Total holdings of bluechip wallets",
    ///      "examples": [
    ///        "50000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "bundleHoldingsRatio": {
    ///      "description": "Ratio of bundle holdings to total supply",
    ///      "examples": [
    ///        "0.018"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "bundleTotalHolders": {
    ///      "description": "Number of bundle wallet holders",
    ///      "examples": [
    ///        "12"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "bundleTotalHoldings": {
    ///      "description": "Total holdings of bundle wallets",
    ///      "examples": [
    ///        "18000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "circulatingSupply": {
    ///      "description": "Circulating supply of the token",
    ///      "examples": [
    ///        "900000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "completionRatio": {
    ///      "description": "Bonding curve completion ratio",
    ///      "examples": [
    ///        "1.0"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "creatorsHoldingsRatio": {
    ///      "description": "ENTITY.TOKEN_MARKET_DATA.CREATORS_HOLDINGS_RATIO",
    ///      "examples": [
    ///        "0.10"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "creatorsTotalHolders": {
    ///      "description": "ENTITY.TOKEN_MARKET_DATA.CREATORS_TOTAL_HOLDERS",
    ///      "examples": [
    ///        "1"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "creatorsTotalHoldings": {
    ///      "description": "ENTITY.TOKEN_MARKET_DATA.CREATORS_TOTAL_HOLDINGS",
    ///      "examples": [
    ///        "100000000.00"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "devHoldingsRatio": {
    ///      "description": "Ratio of developer holdings to total supply",
    ///      "examples": [
    ///        "0.005"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "devTotalHolders": {
    ///      "description": "Number of developer wallet holders",
    ///      "examples": [
    ///        "3"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "devTotalHoldings": {
    ///      "description": "Total holdings of developer wallets",
    ///      "examples": [
    ///        "5000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "fdvInSol": {
    ///      "description": "Fully diluted valuation in native token",
    ///      "examples": [
    ///        "200000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "fdvInUsd": {
    ///      "description": "Fully diluted valuation in USD",
    ///      "examples": [
    ///        "200000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "freshHoldingsRatio": {
    ///      "description": "Ratio of fresh wallet holdings to total supply",
    ///      "examples": [
    ///        "0.01"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "freshTotalHolders": {
    ///      "description": "Number of fresh (new) wallet holders",
    ///      "examples": [
    ///        "30"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "freshTotalHoldings": {
    ///      "description": "Total holdings of fresh wallets",
    ///      "examples": [
    ///        "10000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "holders": {
    ///      "description": "Total number of token holders",
    ///      "examples": [
    ///        "1000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "insiderHoldingsRatio": {
    ///      "description": "Ratio of insider holdings to total supply",
    ///      "examples": [
    ///        "0.02"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "insiderTotalHolders": {
    ///      "description": "Number of insider wallet holders",
    ///      "examples": [
    ///        "5"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "insiderTotalHoldings": {
    ///      "description": "Total holdings of insider wallets",
    ///      "examples": [
    ///        "20000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "kolHoldingsRatio": {
    ///      "description": "Ratio of KOL holdings to total supply",
    ///      "examples": [
    ///        "0.03"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "kolTotalHolders": {
    ///      "description": "Number of KOL (Key Opinion Leader) holders",
    ///      "examples": [
    ///        "20"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "kolTotalHoldings": {
    ///      "description": "Total holdings of KOL wallets",
    ///      "examples": [
    ///        "30000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "marketCapInSol": {
    ///      "description": "Market capitalization in native token",
    ///      "examples": [
    ///        "100000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "marketCapInUsd": {
    ///      "description": "Market capitalization in USD",
    ///      "examples": [
    ///        "100000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "maxPoolTvlInSol": {
    ///      "description": "Maximum pool TVL in native token",
    ///      "examples": [
    ///        "1000.45"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "maxPoolTvlInUsd": {
    ///      "description": "Maximum pool TVL in USD",
    ///      "examples": [
    ///        "150000.00"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "phishingHoldingsRatio": {
    ///      "description": "ENTITY.TOKEN_MARKET_DATA.PHISHING_HOLDINGS_RATIO",
    ///      "examples": [
    ///        "0.0005"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "phishingTotalHolders": {
    ///      "description": "ENTITY.TOKEN_MARKET_DATA.PHISHING_TOTAL_HOLDERS",
    ///      "examples": [
    ///        "2"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "phishingTotalHoldings": {
    ///      "description": "ENTITY.TOKEN_MARKET_DATA.PHISHING_TOTAL_HOLDINGS",
    ///      "examples": [
    ///        "50000.00"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "priceInSol": {
    ///      "description": "Token price in native token",
    ///      "examples": [
    ///        "0.00000261383847574915906643405542"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "priceInUsd": {
    ///      "description": "Token price in USD",
    ///      "examples": [
    ///        "0.00000261383847574915906643405542"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "proHoldingsRatio": {
    ///      "description": "Ratio of professional trader holdings to total supply",
    ///      "examples": [
    ///        "0.04"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "proTotalHolders": {
    ///      "description": "Number of professional trader holders",
    ///      "examples": [
    ///        "25"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "proTotalHoldings": {
    ///      "description": "Total holdings of professional traders",
    ///      "examples": [
    ///        "40000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "ratHoldingsRatio": {
    ///      "description": "ENTITY.TOKEN_MARKET_DATA.RAT_HOLDINGS_RATIO",
    ///      "examples": [
    ///        "0.0012"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "ratTotalHolders": {
    ///      "description": "ENTITY.TOKEN_MARKET_DATA.RAT_TOTAL_HOLDERS",
    ///      "examples": [
    ///        "5"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "ratTotalHoldings": {
    ///      "description": "ENTITY.TOKEN_MARKET_DATA.RAT_TOTAL_HOLDINGS",
    ///      "examples": [
    ///        "120000.00"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "sandwishHoldingsRatio": {
    ///      "description": "Ratio of sandwich attack holdings to total supply",
    ///      "examples": [
    ///        "0.015"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "sandwishTotalHolders": {
    ///      "description": "Number of sandwich attack wallet holders",
    ///      "examples": [
    ///        "8"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "sandwishTotalHoldings": {
    ///      "description": "Total holdings of sandwich attack wallets",
    ///      "examples": [
    ///        "15000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "smartHoldingsRatio": {
    ///      "description": "ENTITY.TOKEN_MARKET_DATA.SMART_HOLDINGS_RATIO",
    ///      "examples": [
    ///        "0.03"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "smartTotalHolders": {
    ///      "description": "ENTITY.TOKEN_MARKET_DATA.SMART_TOTAL_HOLDERS",
    ///      "examples": [
    ///        "30"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "smartTotalHoldings": {
    ///      "description": "ENTITY.TOKEN_MARKET_DATA.SMART_TOTAL_HOLDINGS",
    ///      "examples": [
    ///        "3000000.00"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "sniperHoldingsRatio": {
    ///      "description": "Ratio of sniper holdings to total supply",
    ///      "examples": [
    ///        "0.025"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "sniperTotalHolders": {
    ///      "description": "Number of sniper wallet holders",
    ///      "examples": [
    ///        "15"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "sniperTotalHoldings": {
    ///      "description": "Total holdings of sniper wallets",
    ///      "examples": [
    ///        "25000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "top100HoldingsRatio": {
    ///      "description": "Ratio of top 100 holders to total supply",
    ///      "examples": [
    ///        "0.8"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "top100TotalHoldings": {
    ///      "description": "Total holdings of top 100 holders",
    ///      "examples": [
    ///        "800000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "top10HoldingsRatio": {
    ///      "description": "Ratio of top 10 holders to total supply",
    ///      "examples": [
    ///        "0.5"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "top10TotalHoldings": {
    ///      "description": "Total holdings of top 10 holders",
    ///      "examples": [
    ///        "500000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "top50HoldingsRatio": {
    ///      "description": "Ratio of top 50 holders to total supply",
    ///      "examples": [
    ///        "0.3"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "top50TotalHoldings": {
    ///      "description": "Total holdings of top 50 holders",
    ///      "examples": [
    ///        "300000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "totalSupply": {
    ///      "description": "Total supply of the token",
    ///      "examples": [
    ///        "1000000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "totalTvlInSol": {
    ///      "description": "Total value locked in native token",
    ///      "examples": [
    ///        "1000000.45"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "totalTvlInUsd": {
    ///      "description": "Total value locked in USD",
    ///      "examples": [
    ///        "1000000.45"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct GetMarketDataMultiResponseValue {
        /**ENTITY.TOKEN_MARKET_DATA.ATH_MARKET_CAP_IN_USD
All-time-high market cap in USD (max observed since token creation).*/
        #[serde(
            rename = "athMarketCapInUsd",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub ath_market_cap_in_usd: ::std::option::Option<::std::string::String>,
        ///Ratio of bluechip holdings to total supply
        #[serde(
            rename = "bluechipHoldingsRatio",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub bluechip_holdings_ratio: ::std::option::Option<::std::string::String>,
        ///Number of bluechip wallet holders
        #[serde(
            rename = "bluechipTotalHolders",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub bluechip_total_holders: ::std::option::Option<::std::string::String>,
        ///Total holdings of bluechip wallets
        #[serde(
            rename = "bluechipTotalHoldings",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub bluechip_total_holdings: ::std::option::Option<::std::string::String>,
        ///Ratio of bundle holdings to total supply
        #[serde(
            rename = "bundleHoldingsRatio",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub bundle_holdings_ratio: ::std::option::Option<::std::string::String>,
        ///Number of bundle wallet holders
        #[serde(
            rename = "bundleTotalHolders",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub bundle_total_holders: ::std::option::Option<::std::string::String>,
        ///Total holdings of bundle wallets
        #[serde(
            rename = "bundleTotalHoldings",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub bundle_total_holdings: ::std::option::Option<::std::string::String>,
        ///Circulating supply of the token
        #[serde(
            rename = "circulatingSupply",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub circulating_supply: ::std::option::Option<::std::string::String>,
        ///Bonding curve completion ratio
        #[serde(
            rename = "completionRatio",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub completion_ratio: ::std::option::Option<::std::string::String>,
        ///ENTITY.TOKEN_MARKET_DATA.CREATORS_HOLDINGS_RATIO
        #[serde(
            rename = "creatorsHoldingsRatio",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub creators_holdings_ratio: ::std::option::Option<::std::string::String>,
        ///ENTITY.TOKEN_MARKET_DATA.CREATORS_TOTAL_HOLDERS
        #[serde(
            rename = "creatorsTotalHolders",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub creators_total_holders: ::std::option::Option<::std::string::String>,
        ///ENTITY.TOKEN_MARKET_DATA.CREATORS_TOTAL_HOLDINGS
        #[serde(
            rename = "creatorsTotalHoldings",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub creators_total_holdings: ::std::option::Option<::std::string::String>,
        ///Ratio of developer holdings to total supply
        #[serde(
            rename = "devHoldingsRatio",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub dev_holdings_ratio: ::std::option::Option<::std::string::String>,
        ///Number of developer wallet holders
        #[serde(
            rename = "devTotalHolders",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub dev_total_holders: ::std::option::Option<::std::string::String>,
        ///Total holdings of developer wallets
        #[serde(
            rename = "devTotalHoldings",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub dev_total_holdings: ::std::option::Option<::std::string::String>,
        ///Fully diluted valuation in native token
        #[serde(
            rename = "fdvInSol",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub fdv_in_sol: ::std::option::Option<::std::string::String>,
        ///Fully diluted valuation in USD
        #[serde(
            rename = "fdvInUsd",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub fdv_in_usd: ::std::option::Option<::std::string::String>,
        ///Ratio of fresh wallet holdings to total supply
        #[serde(
            rename = "freshHoldingsRatio",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub fresh_holdings_ratio: ::std::option::Option<::std::string::String>,
        ///Number of fresh (new) wallet holders
        #[serde(
            rename = "freshTotalHolders",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub fresh_total_holders: ::std::option::Option<::std::string::String>,
        ///Total holdings of fresh wallets
        #[serde(
            rename = "freshTotalHoldings",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub fresh_total_holdings: ::std::option::Option<::std::string::String>,
        ///Total number of token holders
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub holders: ::std::option::Option<::std::string::String>,
        ///Ratio of insider holdings to total supply
        #[serde(
            rename = "insiderHoldingsRatio",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub insider_holdings_ratio: ::std::option::Option<::std::string::String>,
        ///Number of insider wallet holders
        #[serde(
            rename = "insiderTotalHolders",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub insider_total_holders: ::std::option::Option<::std::string::String>,
        ///Total holdings of insider wallets
        #[serde(
            rename = "insiderTotalHoldings",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub insider_total_holdings: ::std::option::Option<::std::string::String>,
        ///Ratio of KOL holdings to total supply
        #[serde(
            rename = "kolHoldingsRatio",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub kol_holdings_ratio: ::std::option::Option<::std::string::String>,
        ///Number of KOL (Key Opinion Leader) holders
        #[serde(
            rename = "kolTotalHolders",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub kol_total_holders: ::std::option::Option<::std::string::String>,
        ///Total holdings of KOL wallets
        #[serde(
            rename = "kolTotalHoldings",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub kol_total_holdings: ::std::option::Option<::std::string::String>,
        ///Market capitalization in native token
        #[serde(
            rename = "marketCapInSol",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub market_cap_in_sol: ::std::option::Option<::std::string::String>,
        ///Market capitalization in USD
        #[serde(
            rename = "marketCapInUsd",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub market_cap_in_usd: ::std::option::Option<::std::string::String>,
        ///Maximum pool TVL in native token
        #[serde(
            rename = "maxPoolTvlInSol",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub max_pool_tvl_in_sol: ::std::option::Option<::std::string::String>,
        ///Maximum 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>,
        ///ENTITY.TOKEN_MARKET_DATA.PHISHING_HOLDINGS_RATIO
        #[serde(
            rename = "phishingHoldingsRatio",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub phishing_holdings_ratio: ::std::option::Option<::std::string::String>,
        ///ENTITY.TOKEN_MARKET_DATA.PHISHING_TOTAL_HOLDERS
        #[serde(
            rename = "phishingTotalHolders",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub phishing_total_holders: ::std::option::Option<::std::string::String>,
        ///ENTITY.TOKEN_MARKET_DATA.PHISHING_TOTAL_HOLDINGS
        #[serde(
            rename = "phishingTotalHoldings",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub phishing_total_holdings: ::std::option::Option<::std::string::String>,
        ///Token price in native token
        #[serde(
            rename = "priceInSol",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub price_in_sol: ::std::option::Option<::std::string::String>,
        ///Token price in USD
        #[serde(
            rename = "priceInUsd",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub price_in_usd: ::std::option::Option<::std::string::String>,
        ///Ratio of professional trader holdings to total supply
        #[serde(
            rename = "proHoldingsRatio",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub pro_holdings_ratio: ::std::option::Option<::std::string::String>,
        ///Number of professional trader holders
        #[serde(
            rename = "proTotalHolders",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub pro_total_holders: ::std::option::Option<::std::string::String>,
        ///Total holdings of professional traders
        #[serde(
            rename = "proTotalHoldings",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub pro_total_holdings: ::std::option::Option<::std::string::String>,
        ///ENTITY.TOKEN_MARKET_DATA.RAT_HOLDINGS_RATIO
        #[serde(
            rename = "ratHoldingsRatio",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub rat_holdings_ratio: ::std::option::Option<::std::string::String>,
        ///ENTITY.TOKEN_MARKET_DATA.RAT_TOTAL_HOLDERS
        #[serde(
            rename = "ratTotalHolders",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub rat_total_holders: ::std::option::Option<::std::string::String>,
        ///ENTITY.TOKEN_MARKET_DATA.RAT_TOTAL_HOLDINGS
        #[serde(
            rename = "ratTotalHoldings",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub rat_total_holdings: ::std::option::Option<::std::string::String>,
        ///Ratio of sandwich attack holdings to total supply
        #[serde(
            rename = "sandwishHoldingsRatio",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub sandwish_holdings_ratio: ::std::option::Option<::std::string::String>,
        ///Number of sandwich attack wallet holders
        #[serde(
            rename = "sandwishTotalHolders",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub sandwish_total_holders: ::std::option::Option<::std::string::String>,
        ///Total holdings of sandwich attack wallets
        #[serde(
            rename = "sandwishTotalHoldings",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub sandwish_total_holdings: ::std::option::Option<::std::string::String>,
        ///ENTITY.TOKEN_MARKET_DATA.SMART_HOLDINGS_RATIO
        #[serde(
            rename = "smartHoldingsRatio",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub smart_holdings_ratio: ::std::option::Option<::std::string::String>,
        ///ENTITY.TOKEN_MARKET_DATA.SMART_TOTAL_HOLDERS
        #[serde(
            rename = "smartTotalHolders",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub smart_total_holders: ::std::option::Option<::std::string::String>,
        ///ENTITY.TOKEN_MARKET_DATA.SMART_TOTAL_HOLDINGS
        #[serde(
            rename = "smartTotalHoldings",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub smart_total_holdings: ::std::option::Option<::std::string::String>,
        ///Ratio of sniper holdings to total supply
        #[serde(
            rename = "sniperHoldingsRatio",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub sniper_holdings_ratio: ::std::option::Option<::std::string::String>,
        ///Number of sniper wallet holders
        #[serde(
            rename = "sniperTotalHolders",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub sniper_total_holders: ::std::option::Option<::std::string::String>,
        ///Total holdings of sniper wallets
        #[serde(
            rename = "sniperTotalHoldings",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub sniper_total_holdings: ::std::option::Option<::std::string::String>,
        ///Ratio of top 100 holders to total supply
        #[serde(
            rename = "top100HoldingsRatio",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub top100_holdings_ratio: ::std::option::Option<::std::string::String>,
        ///Total holdings of top 100 holders
        #[serde(
            rename = "top100TotalHoldings",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub top100_total_holdings: ::std::option::Option<::std::string::String>,
        ///Ratio of top 10 holders to total supply
        #[serde(
            rename = "top10HoldingsRatio",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub top10_holdings_ratio: ::std::option::Option<::std::string::String>,
        ///Total holdings of top 10 holders
        #[serde(
            rename = "top10TotalHoldings",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub top10_total_holdings: ::std::option::Option<::std::string::String>,
        ///Ratio of top 50 holders to total supply
        #[serde(
            rename = "top50HoldingsRatio",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub top50_holdings_ratio: ::std::option::Option<::std::string::String>,
        ///Total holdings of top 50 holders
        #[serde(
            rename = "top50TotalHoldings",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub top50_total_holdings: ::std::option::Option<::std::string::String>,
        ///Total supply of the token
        #[serde(
            rename = "totalSupply",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub total_supply: ::std::option::Option<::std::string::String>,
        ///Total value locked in native token
        #[serde(
            rename = "totalTvlInSol",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub total_tvl_in_sol: ::std::option::Option<::std::string::String>,
        ///Total value locked in USD
        #[serde(
            rename = "totalTvlInUsd",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub total_tvl_in_usd: ::std::option::Option<::std::string::String>,
    }
    impl ::std::convert::From<&GetMarketDataMultiResponseValue>
    for GetMarketDataMultiResponseValue {
        fn from(value: &GetMarketDataMultiResponseValue) -> Self {
            value.clone()
        }
    }
    impl ::std::default::Default for GetMarketDataMultiResponseValue {
        fn default() -> Self {
            Self {
                ath_market_cap_in_usd: Default::default(),
                bluechip_holdings_ratio: Default::default(),
                bluechip_total_holders: Default::default(),
                bluechip_total_holdings: Default::default(),
                bundle_holdings_ratio: Default::default(),
                bundle_total_holders: Default::default(),
                bundle_total_holdings: Default::default(),
                circulating_supply: Default::default(),
                completion_ratio: Default::default(),
                creators_holdings_ratio: Default::default(),
                creators_total_holders: Default::default(),
                creators_total_holdings: Default::default(),
                dev_holdings_ratio: Default::default(),
                dev_total_holders: Default::default(),
                dev_total_holdings: Default::default(),
                fdv_in_sol: Default::default(),
                fdv_in_usd: Default::default(),
                fresh_holdings_ratio: Default::default(),
                fresh_total_holders: Default::default(),
                fresh_total_holdings: Default::default(),
                holders: Default::default(),
                insider_holdings_ratio: Default::default(),
                insider_total_holders: Default::default(),
                insider_total_holdings: Default::default(),
                kol_holdings_ratio: Default::default(),
                kol_total_holders: Default::default(),
                kol_total_holdings: Default::default(),
                market_cap_in_sol: Default::default(),
                market_cap_in_usd: Default::default(),
                max_pool_tvl_in_sol: Default::default(),
                max_pool_tvl_in_usd: Default::default(),
                phishing_holdings_ratio: Default::default(),
                phishing_total_holders: Default::default(),
                phishing_total_holdings: Default::default(),
                price_in_sol: Default::default(),
                price_in_usd: Default::default(),
                pro_holdings_ratio: Default::default(),
                pro_total_holders: Default::default(),
                pro_total_holdings: Default::default(),
                rat_holdings_ratio: Default::default(),
                rat_total_holders: Default::default(),
                rat_total_holdings: Default::default(),
                sandwish_holdings_ratio: Default::default(),
                sandwish_total_holders: Default::default(),
                sandwish_total_holdings: Default::default(),
                smart_holdings_ratio: Default::default(),
                smart_total_holders: Default::default(),
                smart_total_holdings: Default::default(),
                sniper_holdings_ratio: Default::default(),
                sniper_total_holders: Default::default(),
                sniper_total_holdings: Default::default(),
                top100_holdings_ratio: Default::default(),
                top100_total_holdings: Default::default(),
                top10_holdings_ratio: Default::default(),
                top10_total_holdings: Default::default(),
                top50_holdings_ratio: Default::default(),
                top50_total_holdings: Default::default(),
                total_supply: Default::default(),
                total_tvl_in_sol: Default::default(),
                total_tvl_in_usd: Default::default(),
            }
        }
    }
    impl GetMarketDataMultiResponseValue {
        pub fn builder() -> builder::GetMarketDataMultiResponseValue {
            Default::default()
        }
    }
    ///Token metadata
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Token metadata",
    ///  "type": "object",
    ///  "required": [
    ///    "address",
    ///    "chain",
    ///    "decimals",
    ///    "name",
    ///    "symbol"
    ///  ],
    ///  "properties": {
    ///    "address": {
    ///      "description": "Token contract address",
    ///      "examples": [
    ///        "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "chain": {
    ///      "description": "Blockchain network identifier",
    ///      "examples": [
    ///        "sol"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "coingeckoCoinId": {
    ///      "description": "CoinGecko coin identifier",
    ///      "examples": [
    ///        "usd-coin"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "decimals": {
    ///      "description": "Number of decimal places",
    ///      "examples": [
    ///        "9"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "description": {
    ///      "description": "Token description",
    ///      "examples": [
    ///        "USDC is a stablecoin pegged to the US dollar"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "devLastTokenCreatedAt": {
    ///      "description": "Timestamp of developer last token creation",
    ///      "examples": [
    ///        "2025-12-03T09:23:34.000Z"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "devTotalTokens": {
    ///      "description": "Total number of tokens created by the developer",
    ///      "examples": [
    ///        "163"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "extra": {
    ///      "$ref": "#/components/schemas/TokenExtra"
    ///    },
    ///    "imageUrl": {
    ///      "description": "Token logo image URL",
    ///      "examples": [
    ///        "https://raw.githubusercontent.com/solana-labs/token-list/main/assets/mainnet/EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v/logo.png"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "metadataAddress": {
    ///      "description": "On-chain metadata account address",
    ///      "examples": [
    ///        "metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "name": {
    ///      "description": "Token display name",
    ///      "examples": [
    ///        "USD Coin"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "socialMedias": {
    ///      "$ref": "#/components/schemas/TokenSocialMedias"
    ///    },
    ///    "symbol": {
    ///      "description": "Token ticker symbol",
    ///      "examples": [
    ///        "USDC"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "tokenCreatedAt": {
    ///      "description": "Token creation timestamp (milliseconds)",
    ///      "examples": [
    ///        1710417600000
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "tokenCreatedBlockHeight": {
    ///      "description": "Block height when token was created",
    ///      "examples": [
    ///        "220000000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "tokenCreatedSlot": {
    ///      "description": "Slot number when token was created",
    ///      "examples": [
    ///        "230000000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "tokenCreatedTxSignature": {
    ///      "description": "Transaction signature of token creation",
    ///      "examples": [
    ///        "5dJ1BxPiFT7w7aBdkxNy2jopGZnZoLwRwS8e9GkEXrVz..."
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "tokenCreators": {
    ///      "description": "List of token creators",
    ///      "type": "array",
    ///      "items": {
    ///        "$ref": "#/components/schemas/TokenCreator"
    ///      }
    ///    },
    ///    "updatedAt": {
    ///      "description": "Last updated timestamp",
    ///      "examples": [
    ///        "2026-02-09T08:05:12.345Z"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "uri": {
    ///      "description": "Token metadata URI",
    ///      "examples": [
    ///        "https://arweave.net/abc123"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct GetMetadataMultiResponseValue {
        ///Token contract address
        pub address: ::std::string::String,
        ///Blockchain network identifier
        pub chain: ::std::string::String,
        ///CoinGecko coin identifier
        #[serde(
            rename = "coingeckoCoinId",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub coingecko_coin_id: ::std::option::Option<::std::string::String>,
        ///Number of decimal places
        pub decimals: ::std::string::String,
        ///Token description
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub description: ::std::option::Option<::std::string::String>,
        ///Timestamp of developer last token creation
        #[serde(
            rename = "devLastTokenCreatedAt",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub dev_last_token_created_at: ::std::option::Option<::std::string::String>,
        ///Total number of tokens created by the developer
        #[serde(
            rename = "devTotalTokens",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub dev_total_tokens: ::std::option::Option<::std::string::String>,
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub extra: ::std::option::Option<TokenExtra>,
        ///Token logo image URL
        #[serde(
            rename = "imageUrl",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub image_url: ::std::option::Option<::std::string::String>,
        ///On-chain metadata account address
        #[serde(
            rename = "metadataAddress",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub metadata_address: ::std::option::Option<::std::string::String>,
        ///Token display name
        pub name: ::std::string::String,
        #[serde(
            rename = "socialMedias",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub social_medias: ::std::option::Option<TokenSocialMedias>,
        ///Token ticker symbol
        pub symbol: ::std::string::String,
        ///Token creation timestamp (milliseconds)
        #[serde(
            rename = "tokenCreatedAt",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub token_created_at: ::std::option::Option<i64>,
        ///Block height when token was created
        #[serde(
            rename = "tokenCreatedBlockHeight",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub token_created_block_height: ::std::option::Option<::std::string::String>,
        ///Slot number when token was created
        #[serde(
            rename = "tokenCreatedSlot",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub token_created_slot: ::std::option::Option<::std::string::String>,
        ///Transaction signature of token creation
        #[serde(
            rename = "tokenCreatedTxSignature",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub token_created_tx_signature: ::std::option::Option<::std::string::String>,
        ///List of token creators
        #[serde(
            rename = "tokenCreators",
            default,
            skip_serializing_if = "::std::vec::Vec::is_empty"
        )]
        pub token_creators: ::std::vec::Vec<TokenCreator>,
        ///Last updated timestamp
        #[serde(
            rename = "updatedAt",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub updated_at: ::std::option::Option<::std::string::String>,
        ///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<&GetMetadataMultiResponseValue>
    for GetMetadataMultiResponseValue {
        fn from(value: &GetMetadataMultiResponseValue) -> Self {
            value.clone()
        }
    }
    impl GetMetadataMultiResponseValue {
        pub fn builder() -> builder::GetMetadataMultiResponseValue {
            Default::default()
        }
    }
    ///Token statistics with nested time period data
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Token statistics with nested time period data",
    ///  "type": "object",
    ///  "required": [
    ///    "address",
    ///    "periods"
    ///  ],
    ///  "properties": {
    ///    "address": {
    ///      "description": "Token contract address",
    ///      "examples": [
    ///        "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "periods": {
    ///      "description": "Trade statistics grouped by time period (1m, 5m, 15m, 30m, 1h, 4h, 6h, 24h).\nEach period contains full OHLCV data, trade counts, and previous-period comparisons.\nSee `TokenTradeStatPeriod` schema for all fields.",
    ///      "examples": [
    ///        {
    ///          "6h": {
    ///            "buyVolumeInUsd": "12000.00",
    ///            "buyers": "120",
    ///            "buys": "420",
    ///            "closeInUsd": "0.15600000",
    ///            "currentLiquidityInUsd": "250000.00",
    ///            "highInUsd": "0.15900000",
    ///            "lowInUsd": "0.15100000",
    ///            "openInUsd": "0.15200000",
    ///            "priceChangeRatioInUsd": "0.02631579",
    ///            "sellVolumeInUsd": "9800.00",
    ///            "sellers": "95",
    ///            "sells": "360",
    ///            "totalVolumeInUsd": "21800.00",
    ///            "traders": "215",
    ///            "trades": "780"
    ///          }
    ///        }
    ///      ],
    ///      "type": "object",
    ///      "additionalProperties": {
    ///        "$ref": "#/components/schemas/TokenTradeStatPeriod"
    ///      }
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct GetStatsMultiResponseValue {
        ///Token contract address
        pub address: ::std::string::String,
        /**Trade statistics grouped by time period (1m, 5m, 15m, 30m, 1h, 4h, 6h, 24h).
Each period contains full OHLCV data, trade counts, and previous-period comparisons.
See `TokenTradeStatPeriod` schema for all fields.*/
        pub periods: ::std::collections::HashMap<
            ::std::string::String,
            TokenTradeStatPeriod,
        >,
    }
    impl ::std::convert::From<&GetStatsMultiResponseValue>
    for GetStatsMultiResponseValue {
        fn from(value: &GetStatsMultiResponseValue) -> Self {
            value.clone()
        }
    }
    impl GetStatsMultiResponseValue {
        pub fn builder() -> builder::GetStatsMultiResponseValue {
            Default::default()
        }
    }
    ///`GoPlusSecurityInfo`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "available"
    ///  ],
    ///  "properties": {
    ///    "available": {
    ///      "description": "Whether data is available from this source",
    ///      "examples": [
    ///        true
    ///      ],
    ///      "type": "boolean"
    ///    },
    ///    "buyTax": {
    ///      "description": "Buy tax rate",
    ///      "type": "string"
    ///    },
    ///    "chainSupported": {
    ///      "description": "Whether this source supports the token chain",
    ///      "examples": [
    ///        true
    ///      ],
    ///      "type": "boolean"
    ///    },
    ///    "holderCount": {
    ///      "type": "string"
    ///    },
    ///    "isBlacklisted": {
    ///      "description": "Whether the contract has blacklist",
    ///      "type": "boolean"
    ///    },
    ///    "isFreezable": {
    ///      "description": "Whether the token accounts can be frozen",
    ///      "type": "boolean"
    ///    },
    ///    "isHoneypot": {
    ///      "description": "Whether the token is a honeypot",
    ///      "type": "boolean"
    ///    },
    ///    "isMintable": {
    ///      "description": "Whether the token is mintable",
    ///      "type": "boolean"
    ///    },
    ///    "isOpenSource": {
    ///      "description": "Whether the contract is open source",
    ///      "type": "boolean"
    ///    },
    ///    "isProxy": {
    ///      "description": "Whether it is a proxy contract",
    ///      "type": "boolean"
    ///    },
    ///    "isRenounced": {
    ///      "description": "Whether the contract ownership is renounced",
    ///      "type": "boolean"
    ///    },
    ///    "lastRefreshedAt": {
    ///      "description": "Last refresh timestamp",
    ///      "examples": [
    ///        "2026-05-13T10:00:00"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "lpHolderCount": {
    ///      "type": "string"
    ///    },
    ///    "ownerAddress": {
    ///      "type": "string"
    ///    },
    ///    "raw": {
    ///      "description": "Raw security data from the source"
    ///    },
    ///    "sellTax": {
    ///      "description": "Sell tax rate",
    ///      "type": "string"
    ///    },
    ///    "totalSupply": {
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct GoPlusSecurityInfo {
        ///Whether data is available from this source
        pub available: bool,
        ///Buy tax rate
        #[serde(
            rename = "buyTax",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub buy_tax: ::std::option::Option<::std::string::String>,
        ///Whether this source supports the token chain
        #[serde(
            rename = "chainSupported",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub chain_supported: ::std::option::Option<bool>,
        #[serde(
            rename = "holderCount",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub holder_count: ::std::option::Option<::std::string::String>,
        ///Whether the contract has blacklist
        #[serde(
            rename = "isBlacklisted",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub is_blacklisted: ::std::option::Option<bool>,
        ///Whether the token accounts can be frozen
        #[serde(
            rename = "isFreezable",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub is_freezable: ::std::option::Option<bool>,
        ///Whether the token is a honeypot
        #[serde(
            rename = "isHoneypot",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub is_honeypot: ::std::option::Option<bool>,
        ///Whether the token is mintable
        #[serde(
            rename = "isMintable",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub is_mintable: ::std::option::Option<bool>,
        ///Whether the contract is open source
        #[serde(
            rename = "isOpenSource",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub is_open_source: ::std::option::Option<bool>,
        ///Whether it is a proxy contract
        #[serde(
            rename = "isProxy",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub is_proxy: ::std::option::Option<bool>,
        ///Whether the contract ownership is renounced
        #[serde(
            rename = "isRenounced",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub is_renounced: ::std::option::Option<bool>,
        ///Last refresh timestamp
        #[serde(
            rename = "lastRefreshedAt",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub last_refreshed_at: ::std::option::Option<::std::string::String>,
        #[serde(
            rename = "lpHolderCount",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub lp_holder_count: ::std::option::Option<::std::string::String>,
        #[serde(
            rename = "ownerAddress",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub owner_address: ::std::option::Option<::std::string::String>,
        ///Raw security data from the source
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub raw: ::std::option::Option<::serde_json::Value>,
        ///Sell tax rate
        #[serde(
            rename = "sellTax",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub sell_tax: ::std::option::Option<::std::string::String>,
        #[serde(
            rename = "totalSupply",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub total_supply: ::std::option::Option<::std::string::String>,
    }
    impl ::std::convert::From<&GoPlusSecurityInfo> for GoPlusSecurityInfo {
        fn from(value: &GoPlusSecurityInfo) -> Self {
            value.clone()
        }
    }
    impl GoPlusSecurityInfo {
        pub fn builder() -> builder::GoPlusSecurityInfo {
            Default::default()
        }
    }
    ///`HoneypotIsSecurityInfo`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "available"
    ///  ],
    ///  "properties": {
    ///    "available": {
    ///      "examples": [
    ///        true
    ///      ],
    ///      "type": "boolean"
    ///    },
    ///    "averageTax": {
    ///      "type": "string"
    ///    },
    ///    "buyTax": {
    ///      "type": "string"
    ///    },
    ///    "canNotSell": {
    ///      "type": "integer",
    ///      "format": "int32"
    ///    },
    ///    "canSell": {
    ///      "type": "integer",
    ///      "format": "int32"
    ///    },
    ///    "chainSupported": {
    ///      "examples": [
    ///        true
    ///      ],
    ///      "type": "boolean"
    ///    },
    ///    "highTax": {
    ///      "type": "string"
    ///    },
    ///    "honeypotResult": {
    ///      "type": "string"
    ///    },
    ///    "isHoneypot": {
    ///      "type": "boolean"
    ///    },
    ///    "isOpenSource": {
    ///      "type": "boolean"
    ///    },
    ///    "isRenounced": {
    ///      "type": "boolean"
    ///    },
    ///    "lastRefreshedAt": {
    ///      "examples": [
    ///        "2026-05-13T10:00:00"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "raw": {},
    ///    "sellTax": {
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct HoneypotIsSecurityInfo {
        pub available: bool,
        #[serde(
            rename = "averageTax",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub average_tax: ::std::option::Option<::std::string::String>,
        #[serde(
            rename = "buyTax",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub buy_tax: ::std::option::Option<::std::string::String>,
        #[serde(
            rename = "canNotSell",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub can_not_sell: ::std::option::Option<i32>,
        #[serde(
            rename = "canSell",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub can_sell: ::std::option::Option<i32>,
        #[serde(
            rename = "chainSupported",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub chain_supported: ::std::option::Option<bool>,
        #[serde(
            rename = "highTax",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub high_tax: ::std::option::Option<::std::string::String>,
        #[serde(
            rename = "honeypotResult",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub honeypot_result: ::std::option::Option<::std::string::String>,
        #[serde(
            rename = "isHoneypot",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub is_honeypot: ::std::option::Option<bool>,
        #[serde(
            rename = "isOpenSource",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub is_open_source: ::std::option::Option<bool>,
        #[serde(
            rename = "isRenounced",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub is_renounced: ::std::option::Option<bool>,
        #[serde(
            rename = "lastRefreshedAt",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub last_refreshed_at: ::std::option::Option<::std::string::String>,
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub raw: ::std::option::Option<::serde_json::Value>,
        #[serde(
            rename = "sellTax",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub sell_tax: ::std::option::Option<::std::string::String>,
    }
    impl ::std::convert::From<&HoneypotIsSecurityInfo> for HoneypotIsSecurityInfo {
        fn from(value: &HoneypotIsSecurityInfo) -> Self {
            value.clone()
        }
    }
    impl HoneypotIsSecurityInfo {
        pub fn builder() -> builder::HoneypotIsSecurityInfo {
            Default::default()
        }
    }
    ///Hot token ranking duration
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Hot token ranking duration",
    ///  "type": "string",
    ///  "enum": [
    ///    "1m",
    ///    "5m",
    ///    "1h",
    ///    "4h",
    ///    "24h"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum HotTokenDuration {
        #[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 HotTokenDuration {
        fn from(value: &HotTokenDuration) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for HotTokenDuration {
        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 HotTokenDuration {
        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 HotTokenDuration {
        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 HotTokenDuration {
        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 HotTokenDuration {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    ///Response from IPFS JSON upload — mirrors TS `uploadJson` return type.
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Response from IPFS JSON upload — mirrors TS `uploadJson` return type.",
    ///  "type": "object",
    ///  "required": [
    ///    "cid",
    ///    "url"
    ///  ],
    ///  "properties": {
    ///    "cid": {
    ///      "description": "IPFS content identifier (CID)",
    ///      "examples": [
    ///        "QmHash..."
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "name": {
    ///      "description": "File name",
    ///      "type": "string"
    ///    },
    ///    "size": {
    ///      "description": "Pin size in bytes",
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "url": {
    ///      "description": "Public IPFS URL",
    ///      "examples": [
    ///        "https://ipfs.io/ipfs/QmHash..."
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct IpfsUploadResponse {
        ///IPFS content identifier (CID)
        pub cid: ::std::string::String,
        ///File name
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub name: ::std::option::Option<::std::string::String>,
        ///Pin size in bytes
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub size: ::std::option::Option<i64>,
        ///Public IPFS URL
        pub url: ::std::string::String,
    }
    impl ::std::convert::From<&IpfsUploadResponse> for IpfsUploadResponse {
        fn from(value: &IpfsUploadResponse) -> Self {
            value.clone()
        }
    }
    impl IpfsUploadResponse {
        pub fn builder() -> builder::IpfsUploadResponse {
            Default::default()
        }
    }
    ///`JobDto`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "result",
    ///    "state"
    ///  ],
    ///  "properties": {
    ///    "result": {
    ///      "description": "Job result",
    ///      "examples": [
    ///        {
    ///          "data": {
    ///            "message": "Job completed successfully"
    ///          },
    ///          "success": true
    ///        }
    ///      ],
    ///      "type": "object"
    ///    },
    ///    "state": {
    ///      "description": "Job state",
    ///      "examples": [
    ///        "completed"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct JobDto {
        ///Job result
        pub result: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
        ///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": "Streaming data",
    ///      "examples": [
    ///        {
    ///          "id": "5rKfmXQyMhz7F2zRE6SpWWx3YkSxtA4gFqZD8CwGRYMx5YLTB8NhbiM9xEHG9jruiWdUyUz7Fpz8jmB8SKcjsLqe",
    ///          "result": {
    ///            "data": {
    ///              "message": "Job completed successfully"
    ///            },
    ///            "success": true
    ///          },
    ///          "status": "completed"
    ///        }
    ///      ],
    ///      "type": "object"
    ///    },
    ///    "id": {
    ///      "description": "Streaming job ID",
    ///      "examples": [
    ///        1
    ///      ],
    ///      "type": "number"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct JobStreamingDto {
        ///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()
        }
    }
    ///`KytAddressExposure`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "properties": {
    ///    "category": {
    ///      "description": "Category",
    ///      "examples": [
    ///        "exchange"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "direction": {
    ///      "description": "Direction",
    ///      "examples": [
    ///        "both_directions"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "exposureType": {
    ///      "description": "Exposure type",
    ///      "examples": [
    ///        "indirect"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "value": {
    ///      "description": "Value",
    ///      "examples": [
    ///        "424895.68594"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct KytAddressExposure {
        ///Category
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub category: ::std::option::Option<::std::string::String>,
        ///Direction
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub direction: ::std::option::Option<::std::string::String>,
        ///Exposure type
        #[serde(
            rename = "exposureType",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub exposure_type: ::std::option::Option<::std::string::String>,
        ///Value
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub value: ::std::option::Option<::std::string::String>,
    }
    impl ::std::convert::From<&KytAddressExposure> for KytAddressExposure {
        fn from(value: &KytAddressExposure) -> Self {
            value.clone()
        }
    }
    impl ::std::default::Default for KytAddressExposure {
        fn default() -> Self {
            Self {
                category: Default::default(),
                direction: Default::default(),
                exposure_type: Default::default(),
                value: Default::default(),
            }
        }
    }
    impl KytAddressExposure {
        pub fn builder() -> builder::KytAddressExposure {
            Default::default()
        }
    }
    ///`KytAddressIdentification`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "properties": {
    ///    "addressName": {
    ///      "description": "Address name",
    ///      "examples": [
    ///        "SANCTIONS: OFAC SDN: Xiaobing Yan"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "categoryId": {
    ///      "description": "Category ID",
    ///      "examples": [
    ///        3
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "description": {
    ///      "description": "Description information",
    ///      "examples": [
    ///        "This specific address 12QtD5BFwRsdNsAZY76UVE1xyCGNTojH9h within the cluster has been identified..."
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct KytAddressIdentification {
        ///Address name
        #[serde(
            rename = "addressName",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub address_name: ::std::option::Option<::std::string::String>,
        ///Category ID
        #[serde(
            rename = "categoryId",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub category_id: ::std::option::Option<i64>,
        ///Description information
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub description: ::std::option::Option<::std::string::String>,
    }
    impl ::std::convert::From<&KytAddressIdentification> for KytAddressIdentification {
        fn from(value: &KytAddressIdentification) -> Self {
            value.clone()
        }
    }
    impl ::std::default::Default for KytAddressIdentification {
        fn default() -> Self {
            Self {
                address_name: Default::default(),
                category_id: Default::default(),
                description: Default::default(),
            }
        }
    }
    impl KytAddressIdentification {
        pub fn builder() -> builder::KytAddressIdentification {
            Default::default()
        }
    }
    ///`KytAddressRiskResponse`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "address"
    ///  ],
    ///  "properties": {
    ///    "address": {
    ///      "description": "Address",
    ///      "examples": [
    ///        1.2638660031056791e45
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "addressIdentifications": {
    ///      "description": "Address identification list",
    ///      "type": "array",
    ///      "items": {}
    ///    },
    ///    "addressType": {
    ///      "description": "Address type",
    ///      "examples": [
    ///        "PRIVATE_WALLET"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "cluster": {
    ///      "description": "Cluster",
    ///      "type": "object"
    ///    },
    ///    "exposures": {
    ///      "description": "Exposure list",
    ///      "type": "array",
    ///      "items": {
    ///        "$ref": "#/components/schemas/KytAddressExposure"
    ///      }
    ///    },
    ///    "risk": {
    ///      "description": "Risk level",
    ///      "examples": [
    ///        "Low"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "riskReason": {
    ///      "description": "Risk reason",
    ///      "type": "string"
    ///    },
    ///    "status": {
    ///      "description": "Status",
    ///      "examples": [
    ///        "COMPLETE"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "triggers": {
    ///      "description": "Trigger list",
    ///      "type": "array",
    ///      "items": {}
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct KytAddressRiskResponse {
        ///Address
        pub address: ::std::string::String,
        ///Address identification list
        #[serde(
            rename = "addressIdentifications",
            default,
            skip_serializing_if = "::std::vec::Vec::is_empty"
        )]
        pub address_identifications: ::std::vec::Vec<::serde_json::Value>,
        ///Address type
        #[serde(
            rename = "addressType",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub address_type: ::std::option::Option<::std::string::String>,
        ///Cluster
        #[serde(default, skip_serializing_if = "::serde_json::Map::is_empty")]
        pub cluster: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
        ///Exposure list
        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
        pub exposures: ::std::vec::Vec<KytAddressExposure>,
        ///Risk level
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub risk: ::std::option::Option<::std::string::String>,
        ///Risk reason
        #[serde(
            rename = "riskReason",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub risk_reason: ::std::option::Option<::std::string::String>,
        ///Status
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub status: ::std::option::Option<::std::string::String>,
        ///Trigger list
        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
        pub triggers: ::std::vec::Vec<::serde_json::Value>,
    }
    impl ::std::convert::From<&KytAddressRiskResponse> for KytAddressRiskResponse {
        fn from(value: &KytAddressRiskResponse) -> Self {
            value.clone()
        }
    }
    impl KytAddressRiskResponse {
        pub fn builder() -> builder::KytAddressRiskResponse {
            Default::default()
        }
    }
    ///`KytAlertDetail`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "properties": {
    ///    "alertAmount": {
    ///      "description": "Alert amount",
    ///      "examples": [
    ///        "8868.24"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "alertLevel": {
    ///      "description": "Alert level",
    ///      "examples": [
    ///        "SEVERE"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "categoryId": {
    ///      "description": "Category ID",
    ///      "examples": [
    ///        3
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "exposureType": {
    ///      "description": "Exposure type",
    ///      "examples": [
    ///        "DIRECT"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "externalId": {
    ///      "description": "External ID",
    ///      "examples": [
    ///        "b7d17de0-f890-11ec-83bd-c37b1b9f5365"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "memo": {
    ///      "description": "Memo",
    ///      "type": "string"
    ///    },
    ///    "service": {
    ///      "description": "Service name",
    ///      "examples": [
    ///        "OFAC SDN Blender.io 2022-05-06"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct KytAlertDetail {
        ///Alert amount
        #[serde(
            rename = "alertAmount",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub alert_amount: ::std::option::Option<::std::string::String>,
        ///Alert level
        #[serde(
            rename = "alertLevel",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub alert_level: ::std::option::Option<::std::string::String>,
        ///Category ID
        #[serde(
            rename = "categoryId",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub category_id: ::std::option::Option<i64>,
        ///Exposure type
        #[serde(
            rename = "exposureType",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub exposure_type: ::std::option::Option<::std::string::String>,
        ///External ID
        #[serde(
            rename = "externalId",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub external_id: ::std::option::Option<::std::string::String>,
        ///Memo
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub memo: ::std::option::Option<::std::string::String>,
        ///Service name
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub service: ::std::option::Option<::std::string::String>,
    }
    impl ::std::convert::From<&KytAlertDetail> for KytAlertDetail {
        fn from(value: &KytAlertDetail) -> Self {
            value.clone()
        }
    }
    impl ::std::default::Default for KytAlertDetail {
        fn default() -> Self {
            Self {
                alert_amount: Default::default(),
                alert_level: Default::default(),
                category_id: Default::default(),
                exposure_type: Default::default(),
                external_id: Default::default(),
                memo: Default::default(),
                service: Default::default(),
            }
        }
    }
    impl KytAlertDetail {
        pub fn builder() -> builder::KytAlertDetail {
            Default::default()
        }
    }
    ///`KytAlertsResponse`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "alerts"
    ///  ],
    ///  "properties": {
    ///    "alerts": {
    ///      "description": "Alert list",
    ///      "type": "array",
    ///      "items": {
    ///        "$ref": "#/components/schemas/KytAlertDetail"
    ///      }
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct KytAlertsResponse {
        ///Alert list
        pub alerts: ::std::vec::Vec<KytAlertDetail>,
    }
    impl ::std::convert::From<&KytAlertsResponse> for KytAlertsResponse {
        fn from(value: &KytAlertsResponse) -> Self {
            value.clone()
        }
    }
    impl KytAlertsResponse {
        pub fn builder() -> builder::KytAlertsResponse {
            Default::default()
        }
    }
    ///`KytAlteryaIdentification`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "properties": {
    ///    "address": {
    ///      "description": "Address",
    ///      "examples": [
    ///        7.791193667402015e47
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "chain": {
    ///      "description": "Blockchain network",
    ///      "examples": [
    ///        "eth"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "labels": {
    ///      "description": "Label list",
    ///      "examples": [
    ///        [
    ///          "scam",
    ///          "disputed"
    ///        ]
    ///      ],
    ///      "type": "array",
    ///      "items": {
    ///        "type": "string"
    ///      }
    ///    },
    ///    "object": {
    ///      "description": "Object type",
    ///      "examples": [
    ///        "address_risk_response"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "on_chain_activity": {
    ///      "$ref": "#/components/schemas/KytOnChainActivity"
    ///    },
    ///    "reason": {
    ///      "description": "Risk reason",
    ///      "examples": [
    ///        "scam"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "risk_level": {
    ///      "description": "Risk level",
    ///      "examples": [
    ///        "severe"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "risk_score": {
    ///      "description": "Risk score",
    ///      "examples": [
    ///        "99.99"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct KytAlteryaIdentification {
        ///Address
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub address: ::std::option::Option<::std::string::String>,
        ///Blockchain network
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub chain: ::std::option::Option<::std::string::String>,
        ///Label list
        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
        pub labels: ::std::vec::Vec<::std::string::String>,
        ///Object type
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub object: ::std::option::Option<::std::string::String>,
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub on_chain_activity: ::std::option::Option<KytOnChainActivity>,
        ///Risk reason
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub reason: ::std::option::Option<::std::string::String>,
        ///Risk level
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub risk_level: ::std::option::Option<::std::string::String>,
        ///Risk score
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub risk_score: ::std::option::Option<::std::string::String>,
    }
    impl ::std::convert::From<&KytAlteryaIdentification> for KytAlteryaIdentification {
        fn from(value: &KytAlteryaIdentification) -> Self {
            value.clone()
        }
    }
    impl ::std::default::Default for KytAlteryaIdentification {
        fn default() -> Self {
            Self {
                address: Default::default(),
                chain: Default::default(),
                labels: Default::default(),
                object: Default::default(),
                on_chain_activity: Default::default(),
                reason: Default::default(),
                risk_level: Default::default(),
                risk_score: Default::default(),
            }
        }
    }
    impl KytAlteryaIdentification {
        pub fn builder() -> builder::KytAlteryaIdentification {
            Default::default()
        }
    }
    ///`KytDirectExposureDetail`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "properties": {
    ///    "categoryId": {
    ///      "description": "Category ID",
    ///      "examples": [
    ///        17
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "name": {
    ///      "description": "Name",
    ///      "examples": [
    ///        "BitPay.com"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct KytDirectExposureDetail {
        ///Category ID
        #[serde(
            rename = "categoryId",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub category_id: ::std::option::Option<i64>,
        ///Name
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub name: ::std::option::Option<::std::string::String>,
    }
    impl ::std::convert::From<&KytDirectExposureDetail> for KytDirectExposureDetail {
        fn from(value: &KytDirectExposureDetail) -> Self {
            value.clone()
        }
    }
    impl ::std::default::Default for KytDirectExposureDetail {
        fn default() -> Self {
            Self {
                category_id: Default::default(),
                name: Default::default(),
            }
        }
    }
    impl KytDirectExposureDetail {
        pub fn builder() -> builder::KytDirectExposureDetail {
            Default::default()
        }
    }
    ///`KytDirectExposureResponse`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "properties": {
    ///    "direct": {
    ///      "$ref": "#/components/schemas/KytDirectExposureDetail"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct KytDirectExposureResponse {
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub direct: ::std::option::Option<KytDirectExposureDetail>,
    }
    impl ::std::convert::From<&KytDirectExposureResponse> for KytDirectExposureResponse {
        fn from(value: &KytDirectExposureResponse) -> Self {
            value.clone()
        }
    }
    impl ::std::default::Default for KytDirectExposureResponse {
        fn default() -> Self {
            Self { direct: Default::default() }
        }
    }
    impl KytDirectExposureResponse {
        pub fn builder() -> builder::KytDirectExposureResponse {
            Default::default()
        }
    }
    ///`KytFraudAssessmentResponse`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "properties": {
    ///    "alteryaIdentifications": {
    ///      "description": "Alterya identification list",
    ///      "type": "array",
    ///      "items": {
    ///        "$ref": "#/components/schemas/KytAlteryaIdentification"
    ///      }
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct KytFraudAssessmentResponse {
        ///Alterya identification list
        #[serde(
            rename = "alteryaIdentifications",
            default,
            skip_serializing_if = "::std::vec::Vec::is_empty"
        )]
        pub alterya_identifications: ::std::vec::Vec<KytAlteryaIdentification>,
    }
    impl ::std::convert::From<&KytFraudAssessmentResponse>
    for KytFraudAssessmentResponse {
        fn from(value: &KytFraudAssessmentResponse) -> Self {
            value.clone()
        }
    }
    impl ::std::default::Default for KytFraudAssessmentResponse {
        fn default() -> Self {
            Self {
                alterya_identifications: Default::default(),
            }
        }
    }
    impl KytFraudAssessmentResponse {
        pub fn builder() -> builder::KytFraudAssessmentResponse {
            Default::default()
        }
    }
    ///`KytNetwork`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "string",
    ///  "enum": [
    ///    "Solana",
    ///    "bitcoin",
    ///    "ethereum"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum KytNetwork {
        Solana,
        #[serde(rename = "bitcoin")]
        Bitcoin,
        #[serde(rename = "ethereum")]
        Ethereum,
    }
    impl ::std::convert::From<&Self> for KytNetwork {
        fn from(value: &KytNetwork) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for KytNetwork {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::Solana => f.write_str("Solana"),
                Self::Bitcoin => f.write_str("bitcoin"),
                Self::Ethereum => f.write_str("ethereum"),
            }
        }
    }
    impl ::std::str::FromStr for KytNetwork {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "Solana" => Ok(Self::Solana),
                "bitcoin" => Ok(Self::Bitcoin),
                "ethereum" => Ok(Self::Ethereum),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for KytNetwork {
        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 KytNetwork {
        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 KytNetwork {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    ///`KytNetworkIdentificationOrg`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "properties": {
    ///    "name": {
    ///      "description": "Organization name",
    ///      "examples": [
    ///        "XYZ Cryptocurrency Exchange"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct KytNetworkIdentificationOrg {
        ///Organization name
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub name: ::std::option::Option<::std::string::String>,
    }
    impl ::std::convert::From<&KytNetworkIdentificationOrg>
    for KytNetworkIdentificationOrg {
        fn from(value: &KytNetworkIdentificationOrg) -> Self {
            value.clone()
        }
    }
    impl ::std::default::Default for KytNetworkIdentificationOrg {
        fn default() -> Self {
            Self { name: Default::default() }
        }
    }
    impl KytNetworkIdentificationOrg {
        pub fn builder() -> builder::KytNetworkIdentificationOrg {
            Default::default()
        }
    }
    ///`KytNetworkIdentificationsResponse`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "properties": {
    ///    "count": {
    ///      "description": "Identification count",
    ///      "examples": [
    ///        1
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "networkIdentificationOrgs": {
    ///      "description": "Network identification organization list",
    ///      "type": "array",
    ///      "items": {
    ///        "$ref": "#/components/schemas/KytNetworkIdentificationOrg"
    ///      }
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct KytNetworkIdentificationsResponse {
        ///Identification count
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub count: ::std::option::Option<i64>,
        ///Network identification organization list
        #[serde(
            rename = "networkIdentificationOrgs",
            default,
            skip_serializing_if = "::std::vec::Vec::is_empty"
        )]
        pub network_identification_orgs: ::std::vec::Vec<KytNetworkIdentificationOrg>,
    }
    impl ::std::convert::From<&KytNetworkIdentificationsResponse>
    for KytNetworkIdentificationsResponse {
        fn from(value: &KytNetworkIdentificationsResponse) -> Self {
            value.clone()
        }
    }
    impl ::std::default::Default for KytNetworkIdentificationsResponse {
        fn default() -> Self {
            Self {
                count: Default::default(),
                network_identification_orgs: Default::default(),
            }
        }
    }
    impl KytNetworkIdentificationsResponse {
        pub fn builder() -> builder::KytNetworkIdentificationsResponse {
            Default::default()
        }
    }
    ///`KytOnChainActivity`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "properties": {
    ///    "first_transaction_at": {
    ///      "description": "First transaction timestamp",
    ///      "examples": [
    ///        1724317680000
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct KytOnChainActivity {
        ///First transaction timestamp
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub first_transaction_at: ::std::option::Option<i64>,
    }
    impl ::std::convert::From<&KytOnChainActivity> for KytOnChainActivity {
        fn from(value: &KytOnChainActivity) -> Self {
            value.clone()
        }
    }
    impl ::std::default::Default for KytOnChainActivity {
        fn default() -> Self {
            Self {
                first_transaction_at: Default::default(),
            }
        }
    }
    impl KytOnChainActivity {
        pub fn builder() -> builder::KytOnChainActivity {
            Default::default()
        }
    }
    ///`KytRegisterAddressInput`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "address"
    ///  ],
    ///  "properties": {
    ///    "address": {
    ///      "description": "Address",
    ///      "examples": [
    ///        1.2638660031056791e45
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct KytRegisterAddressInput {
        ///Address
        pub address: ::std::string::String,
    }
    impl ::std::convert::From<&KytRegisterAddressInput> for KytRegisterAddressInput {
        fn from(value: &KytRegisterAddressInput) -> Self {
            value.clone()
        }
    }
    impl KytRegisterAddressInput {
        pub fn builder() -> builder::KytRegisterAddressInput {
            Default::default()
        }
    }
    ///`KytRegisterAddressResponse`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "address"
    ///  ],
    ///  "properties": {
    ///    "address": {
    ///      "description": "Address",
    ///      "examples": [
    ///        1.2638660031056791e45
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct KytRegisterAddressResponse {
        ///Address
        pub address: ::std::string::String,
    }
    impl ::std::convert::From<&KytRegisterAddressResponse>
    for KytRegisterAddressResponse {
        fn from(value: &KytRegisterAddressResponse) -> Self {
            value.clone()
        }
    }
    impl KytRegisterAddressResponse {
        pub fn builder() -> builder::KytRegisterAddressResponse {
            Default::default()
        }
    }
    ///`KytRegisterTransferInput`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "asset",
    ///    "direction",
    ///    "network",
    ///    "transferReference"
    ///  ],
    ///  "properties": {
    ///    "asset": {
    ///      "description": "Asset type",
    ///      "examples": [
    ///        "SOL"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "direction": {
    ///      "$ref": "#/components/schemas/TransferDirection"
    ///    },
    ///    "network": {
    ///      "$ref": "#/components/schemas/KytNetwork"
    ///    },
    ///    "transferReference": {
    ///      "description": "Transfer hash/transaction ID",
    ///      "examples": [
    ///        "39z5QAprVrzaFzfHu1JHPgBf9dSqYdNYhH31d3PEd4hWiWL1LML7qCct5MHGxaRAgjjj1nC3XUyLwtzGQmYqUk4y:7xfh4GGMbM3bjpWsTsmBTCfSyuvXFuqnC89fShAqk5Nj"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct KytRegisterTransferInput {
        ///Asset type
        pub asset: ::std::string::String,
        pub direction: TransferDirection,
        pub network: KytNetwork,
        ///Transfer hash/transaction ID
        #[serde(rename = "transferReference")]
        pub transfer_reference: ::std::string::String,
    }
    impl ::std::convert::From<&KytRegisterTransferInput> for KytRegisterTransferInput {
        fn from(value: &KytRegisterTransferInput) -> Self {
            value.clone()
        }
    }
    impl KytRegisterTransferInput {
        pub fn builder() -> builder::KytRegisterTransferInput {
            Default::default()
        }
    }
    ///`KytRegisterWithdrawalInput`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "address",
    ///    "asset",
    ///    "assetAmount",
    ///    "attemptTimestamp",
    ///    "network"
    ///  ],
    ///  "properties": {
    ///    "address": {
    ///      "description": "Withdrawal address",
    ///      "examples": [
    ///        "D1Mc6j9xQWgR1o1Z7yU5nVVXFQiAYx7FG9AW1aVfwrUM"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "asset": {
    ///      "description": "Asset type",
    ///      "examples": [
    ///        "SOL"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "assetAmount": {
    ///      "description": "Asset amount",
    ///      "examples": [
    ///        "5"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "assetDenomination": {
    ///      "description": "Asset denomination (e.g., USD)",
    ///      "examples": [
    ///        "USD"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "assetId": {
    ///      "description": "Asset ID (optional)",
    ///      "type": "string"
    ///    },
    ///    "assetPrice": {
    ///      "description": "Asset price",
    ///      "examples": [
    ///        "1000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "attemptTimestamp": {
    ///      "description": "Attempt timestamp",
    ///      "examples": [
    ///        "2026-01-04T17:25:40.008307"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "memo": {
    ///      "description": "Memo information (optional)",
    ///      "type": "string"
    ///    },
    ///    "network": {
    ///      "$ref": "#/components/schemas/KytNetwork"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct KytRegisterWithdrawalInput {
        ///Withdrawal address
        pub address: ::std::string::String,
        ///Asset type
        pub asset: ::std::string::String,
        ///Asset amount
        #[serde(rename = "assetAmount")]
        pub asset_amount: ::std::string::String,
        ///Asset denomination (e.g., USD)
        #[serde(
            rename = "assetDenomination",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub asset_denomination: ::std::option::Option<::std::string::String>,
        ///Asset ID (optional)
        #[serde(
            rename = "assetId",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub asset_id: ::std::option::Option<::std::string::String>,
        ///Asset price
        #[serde(
            rename = "assetPrice",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub asset_price: ::std::option::Option<::std::string::String>,
        ///Attempt timestamp
        #[serde(rename = "attemptTimestamp")]
        pub attempt_timestamp: ::std::string::String,
        ///Memo information (optional)
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub memo: ::std::option::Option<::std::string::String>,
        pub network: KytNetwork,
    }
    impl ::std::convert::From<&KytRegisterWithdrawalInput>
    for KytRegisterWithdrawalInput {
        fn from(value: &KytRegisterWithdrawalInput) -> Self {
            value.clone()
        }
    }
    impl KytRegisterWithdrawalInput {
        pub fn builder() -> builder::KytRegisterWithdrawalInput {
            Default::default()
        }
    }
    ///`KytTransferBaseResponse`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "asset",
    ///    "externalId",
    ///    "network",
    ///    "transferReference"
    ///  ],
    ///  "properties": {
    ///    "asset": {
    ///      "description": "Asset type",
    ///      "examples": [
    ///        "BTC"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "assetAmount": {
    ///      "description": "Asset amount",
    ///      "examples": [
    ///        "11.35113454"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "assetId": {
    ///      "description": "Asset ID",
    ///      "type": "string"
    ///    },
    ///    "externalId": {
    ///      "description": "External ID (UUID)",
    ///      "examples": [
    ///        "393905a7-bb96-394b-9e20-3645298c1079"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "idx": {
    ///      "description": "Index",
    ///      "examples": [
    ///        2
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "memo": {
    ///      "description": "Memo information",
    ///      "type": "string"
    ///    },
    ///    "network": {
    ///      "description": "Blockchain network",
    ///      "examples": [
    ///        "BITCOIN"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "outputAddress": {
    ///      "description": "Output address",
    ///      "examples": [
    ///        "17A16QmavnUfCW11DAApiJxp7ARnxN5pGX"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "timestamp": {
    ///      "description": "Timestamp",
    ///      "examples": [
    ///        "2021-11-16T18:33:33.000+00:00"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "transferReference": {
    ///      "description": "Transfer reference (transaction hash and address)",
    ///      "examples": [
    ///        "9f318afbad2a183f97750bc51a75b582ad8f9e9cbfb50401148857ca27cde10c:17A16QmavnUfCW11DAApiJxp7ARnxN5pGX"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "tx": {
    ///      "description": "Transaction hash",
    ///      "examples": [
    ///        "9f318afbad2a183f97750bc51a75b582ad8f9e9cbfb50401148857ca27cde10c"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "updatedAt": {
    ///      "description": "Updated timestamp",
    ///      "examples": [
    ///        "2022-03-16T16:17:19.613215"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "usdAmount": {
    ///      "description": "USD amount",
    ///      "examples": [
    ///        "722099.75"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct KytTransferBaseResponse {
        ///Asset type
        pub asset: ::std::string::String,
        ///Asset amount
        #[serde(
            rename = "assetAmount",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub asset_amount: ::std::option::Option<::std::string::String>,
        ///Asset ID
        #[serde(
            rename = "assetId",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub asset_id: ::std::option::Option<::std::string::String>,
        ///External ID (UUID)
        #[serde(rename = "externalId")]
        pub external_id: ::std::string::String,
        ///Index
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub idx: ::std::option::Option<i64>,
        ///Memo information
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub memo: ::std::option::Option<::std::string::String>,
        ///Blockchain network
        pub network: ::std::string::String,
        ///Output address
        #[serde(
            rename = "outputAddress",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub output_address: ::std::option::Option<::std::string::String>,
        ///Timestamp
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub timestamp: ::std::option::Option<::std::string::String>,
        ///Transfer reference (transaction hash and address)
        #[serde(rename = "transferReference")]
        pub transfer_reference: ::std::string::String,
        ///Transaction hash
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub tx: ::std::option::Option<::std::string::String>,
        ///Updated timestamp
        #[serde(
            rename = "updatedAt",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub updated_at: ::std::option::Option<::std::string::String>,
        ///USD amount
        #[serde(
            rename = "usdAmount",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub usd_amount: ::std::option::Option<::std::string::String>,
    }
    impl ::std::convert::From<&KytTransferBaseResponse> for KytTransferBaseResponse {
        fn from(value: &KytTransferBaseResponse) -> Self {
            value.clone()
        }
    }
    impl KytTransferBaseResponse {
        pub fn builder() -> builder::KytTransferBaseResponse {
            Default::default()
        }
    }
    ///`KytWithdrawalAddressIdentificationsResponse`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "properties": {
    ///    "chainalysisIdentifications": {
    ///      "description": "Chainalysis address identification list",
    ///      "type": "array",
    ///      "items": {
    ///        "$ref": "#/components/schemas/KytAddressIdentification"
    ///      }
    ///    },
    ///    "customAddresses": {
    ///      "description": "Custom address list",
    ///      "type": "array",
    ///      "items": {}
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct KytWithdrawalAddressIdentificationsResponse {
        ///Chainalysis address identification list
        #[serde(
            rename = "chainalysisIdentifications",
            default,
            skip_serializing_if = "::std::vec::Vec::is_empty"
        )]
        pub chainalysis_identifications: ::std::vec::Vec<KytAddressIdentification>,
        ///Custom address list
        #[serde(
            rename = "customAddresses",
            default,
            skip_serializing_if = "::std::vec::Vec::is_empty"
        )]
        pub custom_addresses: ::std::vec::Vec<::serde_json::Value>,
    }
    impl ::std::convert::From<&KytWithdrawalAddressIdentificationsResponse>
    for KytWithdrawalAddressIdentificationsResponse {
        fn from(value: &KytWithdrawalAddressIdentificationsResponse) -> Self {
            value.clone()
        }
    }
    impl ::std::default::Default for KytWithdrawalAddressIdentificationsResponse {
        fn default() -> Self {
            Self {
                chainalysis_identifications: Default::default(),
                custom_addresses: Default::default(),
            }
        }
    }
    impl KytWithdrawalAddressIdentificationsResponse {
        pub fn builder() -> builder::KytWithdrawalAddressIdentificationsResponse {
            Default::default()
        }
    }
    ///`KytWithdrawalBaseResponse`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "address",
    ///    "asset",
    ///    "assetAmount",
    ///    "attemptIdentifier",
    ///    "externalId",
    ///    "network",
    ///    "updatedAt",
    ///    "usdAmount"
    ///  ],
    ///  "properties": {
    ///    "address": {
    ///      "description": "Address",
    ///      "examples": [
    ///        "1EM4e8eu2S2RQrbS8C6aYnunWpkAwQ8GtG"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "asset": {
    ///      "description": "Asset type",
    ///      "examples": [
    ///        "BTC"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "assetAmount": {
    ///      "description": "Asset amount",
    ///      "examples": [
    ///        "5"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "assetId": {
    ///      "description": "Asset ID",
    ///      "type": "string"
    ///    },
    ///    "attemptIdentifier": {
    ///      "description": "Attempt identifier",
    ///      "examples": [
    ///        "attempt1"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "externalId": {
    ///      "description": "External ID (UUID)",
    ///      "examples": [
    ///        "9855b826-2bad-31f2-8a89-96f164293a83"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "memo": {
    ///      "description": "Memo information",
    ///      "type": "string"
    ///    },
    ///    "network": {
    ///      "description": "Blockchain network",
    ///      "examples": [
    ///        "Bitcoin"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "updatedAt": {
    ///      "description": "Updated timestamp",
    ///      "examples": [
    ///        "2020-12-09T17:25:40.008307"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "usdAmount": {
    ///      "description": "USD amount",
    ///      "examples": [
    ///        "1000"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct KytWithdrawalBaseResponse {
        ///Address
        pub address: ::std::string::String,
        ///Asset type
        pub asset: ::std::string::String,
        ///Asset amount
        #[serde(rename = "assetAmount")]
        pub asset_amount: ::std::string::String,
        ///Asset ID
        #[serde(
            rename = "assetId",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub asset_id: ::std::option::Option<::std::string::String>,
        ///Attempt identifier
        #[serde(rename = "attemptIdentifier")]
        pub attempt_identifier: ::std::string::String,
        ///External ID (UUID)
        #[serde(rename = "externalId")]
        pub external_id: ::std::string::String,
        ///Memo information
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub memo: ::std::option::Option<::std::string::String>,
        ///Blockchain network
        pub network: ::std::string::String,
        ///Updated timestamp
        #[serde(rename = "updatedAt")]
        pub updated_at: ::std::string::String,
        ///USD amount
        #[serde(rename = "usdAmount")]
        pub usd_amount: ::std::string::String,
    }
    impl ::std::convert::From<&KytWithdrawalBaseResponse> for KytWithdrawalBaseResponse {
        fn from(value: &KytWithdrawalBaseResponse) -> Self {
            value.clone()
        }
    }
    impl KytWithdrawalBaseResponse {
        pub fn builder() -> builder::KytWithdrawalBaseResponse {
            Default::default()
        }
    }
    ///Launchpad tag for token filtering
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Launchpad tag for token filtering",
    ///  "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 LaunchpadTag {
        #[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 LaunchpadTag {
        fn from(value: &LaunchpadTag) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for LaunchpadTag {
        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 LaunchpadTag {
        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 LaunchpadTag {
        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 LaunchpadTag {
        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 LaunchpadTag {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    ///Mint/burn type filter
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Mint/burn type filter",
    ///  "type": "string",
    ///  "enum": [
    ///    "all",
    ///    "mint",
    ///    "burn"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum MintBurnType {
        #[serde(rename = "all")]
        All,
        #[serde(rename = "mint")]
        Mint,
        #[serde(rename = "burn")]
        Burn,
    }
    impl ::std::convert::From<&Self> for MintBurnType {
        fn from(value: &MintBurnType) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for MintBurnType {
        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 MintBurnType {
        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 MintBurnType {
        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 MintBurnType {
        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 MintBurnType {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    ///Single token net-worth item (mirrors TS WalletNetWorthItemDTO).
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Single token net-worth item (mirrors TS WalletNetWorthItemDTO).",
    ///  "type": "object",
    ///  "required": [
    ///    "amount",
    ///    "chain",
    ///    "decimals",
    ///    "isActive",
    ///    "name",
    ///    "priceInNative",
    ///    "priceInUsd",
    ///    "symbol",
    ///    "tokenAddress",
    ///    "valueInNative",
    ///    "valueInUsd"
    ///  ],
    ///  "properties": {
    ///    "accuAmount": {
    ///      "description": "Accumulated net token position in token native units:\nbuy_amount - sell_amount + transfer_in_amount - transfer_out_amount.\nMirrors GMGN `accu_amount`. None when all four source fields are absent.",
    ///      "type": "string"
    ///    },
    ///    "amount": {
    ///      "description": "Token holding amount",
    ///      "examples": [
    ///        "1000.50"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "avgCostUsd": {
    ///      "description": "Average cost per token in USD (balance_cost_avg_in_usd; sparse ~0.2% fill rate)",
    ///      "type": "string"
    ///    },
    ///    "chain": {
    ///      "description": "Blockchain network identifier",
    ///      "examples": [
    ///        "sol"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "decimals": {
    ///      "description": "Token decimal places",
    ///      "examples": [
    ///        6
    ///      ],
    ///      "type": "integer",
    ///      "format": "int32"
    ///    },
    ///    "isActive": {
    ///      "description": "Whether the wallet currently holds a non-zero balance",
    ///      "type": "boolean"
    ///    },
    ///    "lastActiveAt": {
    ///      "description": "Last active timestamp (ms since epoch)",
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "logoUri": {
    ///      "description": "Token logo URI",
    ///      "examples": [
    ///        "https://s1.chainstream.io/tokens/images/usdc.webp"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "name": {
    ///      "description": "Token display name",
    ///      "examples": [
    ///        "USD Coin"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "priceInNative": {
    ///      "description": "Token price in native token",
    ///      "examples": [
    ///        "0.00000667"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "priceInUsd": {
    ///      "description": "Token price in USD",
    ///      "examples": [
    ///        "1.0001"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "realizedPnlInUsd": {
    ///      "description": "Realized PnL in USD (all-time cumulative)",
    ///      "type": "string"
    ///    },
    ///    "symbol": {
    ///      "description": "Token ticker symbol",
    ///      "examples": [
    ///        "USDC"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "tokenAddress": {
    ///      "description": "Token contract address",
    ///      "examples": [
    ///        "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "unrealizedPnlInUsd": {
    ///      "description": "Unrealized PnL in USD (current open position)",
    ///      "type": "string"
    ///    },
    ///    "valueInNative": {
    ///      "description": "Holding value in native token",
    ///      "examples": [
    ///        "6.67"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "valueInUsd": {
    ///      "description": "Holding value in USD",
    ///      "examples": [
    ///        "1000.60"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "walletTokenTags": {
    ///      "description": "Trader classification tags",
    ///      "type": "array",
    ///      "items": {
    ///        "type": "string"
    ///      }
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct NetWorthByTokensItem {
        /**Accumulated net token position in token native units:
buy_amount - sell_amount + transfer_in_amount - transfer_out_amount.
Mirrors GMGN `accu_amount`. None when all four source fields are absent.*/
        #[serde(
            rename = "accuAmount",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub accu_amount: ::std::option::Option<::std::string::String>,
        ///Token holding amount
        pub amount: ::std::string::String,
        ///Average cost per token in USD (balance_cost_avg_in_usd; sparse ~0.2% fill rate)
        #[serde(
            rename = "avgCostUsd",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub avg_cost_usd: ::std::option::Option<::std::string::String>,
        ///Blockchain network identifier
        pub chain: ::std::string::String,
        ///Token decimal places
        pub decimals: i32,
        ///Whether the wallet currently holds a non-zero balance
        #[serde(rename = "isActive")]
        pub is_active: bool,
        ///Last active timestamp (ms since epoch)
        #[serde(
            rename = "lastActiveAt",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub last_active_at: ::std::option::Option<i64>,
        ///Token logo URI
        #[serde(
            rename = "logoUri",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub logo_uri: ::std::option::Option<::std::string::String>,
        ///Token display name
        pub name: ::std::string::String,
        ///Token price in native token
        #[serde(rename = "priceInNative")]
        pub price_in_native: ::std::string::String,
        ///Token price in USD
        #[serde(rename = "priceInUsd")]
        pub price_in_usd: ::std::string::String,
        ///Realized PnL in USD (all-time cumulative)
        #[serde(
            rename = "realizedPnlInUsd",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub realized_pnl_in_usd: ::std::option::Option<::std::string::String>,
        ///Token ticker symbol
        pub symbol: ::std::string::String,
        ///Token contract address
        #[serde(rename = "tokenAddress")]
        pub token_address: ::std::string::String,
        ///Unrealized PnL in USD (current open position)
        #[serde(
            rename = "unrealizedPnlInUsd",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub unrealized_pnl_in_usd: ::std::option::Option<::std::string::String>,
        ///Holding value in native token
        #[serde(rename = "valueInNative")]
        pub value_in_native: ::std::string::String,
        ///Holding value in USD
        #[serde(rename = "valueInUsd")]
        pub value_in_usd: ::std::string::String,
        ///Trader classification tags
        #[serde(
            rename = "walletTokenTags",
            default,
            skip_serializing_if = "::std::vec::Vec::is_empty"
        )]
        pub wallet_token_tags: ::std::vec::Vec<::std::string::String>,
    }
    impl ::std::convert::From<&NetWorthByTokensItem> for NetWorthByTokensItem {
        fn from(value: &NetWorthByTokensItem) -> Self {
            value.clone()
        }
    }
    impl NetWorthByTokensItem {
        pub fn builder() -> builder::NetWorthByTokensItem {
            Default::default()
        }
    }
    ///Wallet net-worth by tokens result (mirrors TS WalletNetWorthByTokensResult).
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Wallet net-worth by tokens result (mirrors TS WalletNetWorthByTokensResult).",
    ///  "type": "object",
    ///  "required": [
    ///    "currentTimestamp",
    ///    "data",
    ///    "totalValueInNative",
    ///    "totalValueInUsd",
    ///    "walletAddress"
    ///  ],
    ///  "properties": {
    ///    "currentTimestamp": {
    ///      "description": "Current server timestamp",
    ///      "examples": [
    ///        "2025-10-30T03:33:40.980Z"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "data": {
    ///      "description": "List of token net-worth items",
    ///      "type": "array",
    ///      "items": {
    ///        "$ref": "#/components/schemas/NetWorthByTokensItem"
    ///      }
    ///    },
    ///    "totalValueInNative": {
    ///      "description": "Total portfolio value in native token",
    ///      "examples": [
    ///        "82.31"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "totalValueInUsd": {
    ///      "description": "Total portfolio value in USD",
    ///      "examples": [
    ///        "12345.67"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "walletAddress": {
    ///      "description": "Wallet address",
    ///      "examples": [
    ///        "3xd4LGVWtYXLBspR6X5JWbW49NXmEehfPtX6Kqx98b4w"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct NetWorthByTokensResult {
        ///Current server timestamp
        #[serde(rename = "currentTimestamp")]
        pub current_timestamp: ::std::string::String,
        ///List of token net-worth items
        pub data: ::std::vec::Vec<NetWorthByTokensItem>,
        ///Total portfolio value in native token
        #[serde(rename = "totalValueInNative")]
        pub total_value_in_native: ::std::string::String,
        ///Total portfolio value in USD
        #[serde(rename = "totalValueInUsd")]
        pub total_value_in_usd: ::std::string::String,
        ///Wallet address
        #[serde(rename = "walletAddress")]
        pub wallet_address: ::std::string::String,
    }
    impl ::std::convert::From<&NetWorthByTokensResult> for NetWorthByTokensResult {
        fn from(value: &NetWorthByTokensResult) -> Self {
            value.clone()
        }
    }
    impl NetWorthByTokensResult {
        pub fn builder() -> builder::NetWorthByTokensResult {
            Default::default()
        }
    }
    ///Single data point in a net-worth chart time series.
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Single data point in a net-worth chart time series.",
    ///  "type": "object",
    ///  "required": [
    ///    "netWorth",
    ///    "netWorthChange",
    ///    "netWorthChangePercent",
    ///    "timestamp"
    ///  ],
    ///  "properties": {
    ///    "netWorth": {
    ///      "description": "Net worth value in USD",
    ///      "examples": [
    ///        "13210463.21"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "netWorthChange": {
    ///      "description": "Net worth change from previous snapshot",
    ///      "examples": [
    ///        "1971274.94"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "netWorthChangePercent": {
    ///      "description": "Net worth change percentage",
    ///      "examples": [
    ///        "17.54"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "timestamp": {
    ///      "description": "Snapshot timestamp",
    ///      "examples": [
    ///        "2025-07-30T23:59:59.000Z"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct NetWorthHistoryItem {
        ///Net worth value in USD
        #[serde(rename = "netWorth")]
        pub net_worth: ::std::string::String,
        ///Net worth change from previous snapshot
        #[serde(rename = "netWorthChange")]
        pub net_worth_change: ::std::string::String,
        ///Net worth change percentage
        #[serde(rename = "netWorthChangePercent")]
        pub net_worth_change_percent: ::std::string::String,
        ///Snapshot timestamp
        pub timestamp: ::std::string::String,
    }
    impl ::std::convert::From<&NetWorthHistoryItem> for NetWorthHistoryItem {
        fn from(value: &NetWorthHistoryItem) -> Self {
            value.clone()
        }
    }
    impl NetWorthHistoryItem {
        pub fn builder() -> builder::NetWorthHistoryItem {
            Default::default()
        }
    }
    ///`NetWorthSummaryValue`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "value"
    ///  ],
    ///  "properties": {
    ///    "value": {
    ///      "description": "Net worth value in USD",
    ///      "examples": [
    ///        "1764819473.530063"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct NetWorthSummaryValue {
        ///Net worth value in USD
        pub value: ::std::string::String,
    }
    impl ::std::convert::From<&NetWorthSummaryValue> for NetWorthSummaryValue {
        fn from(value: &NetWorthSummaryValue) -> Self {
            value.clone()
        }
    }
    impl NetWorthSummaryValue {
        pub fn builder() -> builder::NetWorthSummaryValue {
            Default::default()
        }
    }
    ///Pagination direction
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Pagination direction",
    ///  "type": "string",
    ///  "enum": [
    ///    "next",
    ///    "prev"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum PageDirection {
        #[serde(rename = "next")]
        Next,
        #[serde(rename = "prev")]
        Prev,
    }
    impl ::std::convert::From<&Self> for PageDirection {
        fn from(value: &PageDirection) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for PageDirection {
        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 PageDirection {
        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 PageDirection {
        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 PageDirection {
        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 PageDirection {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    ///Generic pagination response
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Generic pagination response",
    ///  "type": "object",
    ///  "required": [
    ///    "data"
    ///  ],
    ///  "properties": {
    ///    "data": {
    ///      "description": "Page data",
    ///      "type": "array",
    ///      "items": {
    ///        "description": "Balance update record",
    ///        "type": "object",
    ///        "required": [
    ///          "accountOwnerAddress",
    ///          "balanceChange",
    ///          "balanceChangeInNative",
    ///          "balanceChangeInUsd",
    ///          "blockHash",
    ///          "blockHeight",
    ///          "blockTimestamp",
    ///          "changeType",
    ///          "index",
    ///          "postBalance",
    ///          "postBalanceInNative",
    ///          "postBalanceInUsd",
    ///          "preBalance",
    ///          "preBalanceInNative",
    ///          "preBalanceInUsd",
    ///          "tokenAccountAddress",
    ///          "tokenAddress",
    ///          "transactionSignature",
    ///          "type"
    ///        ],
    ///        "properties": {
    ///          "accountOwnerAddress": {
    ///            "description": "Account owner wallet address",
    ///            "type": "string"
    ///          },
    ///          "balanceChange": {
    ///            "description": "Balance change amount",
    ///            "type": "string"
    ///          },
    ///          "balanceChangeInNative": {
    ///            "description": "Balance change in native token",
    ///            "type": "string"
    ///          },
    ///          "balanceChangeInUsd": {
    ///            "description": "Balance change in USD",
    ///            "type": "string"
    ///          },
    ///          "blockHash": {
    ///            "description": "Block hash",
    ///            "type": "string"
    ///          },
    ///          "blockHeight": {
    ///            "description": "Block height",
    ///            "type": "integer",
    ///            "format": "int64"
    ///          },
    ///          "blockSlot": {
    ///            "description": "Block slot number",
    ///            "type": "integer",
    ///            "format": "int64"
    ///          },
    ///          "blockTimestamp": {
    ///            "description": "Block timestamp (milliseconds)",
    ///            "type": "integer",
    ///            "format": "int64"
    ///          },
    ///          "changeType": {
    ///            "$ref": "#/components/schemas/BalanceChangeType"
    ///          },
    ///          "index": {
    ///            "description": "Transaction instruction index",
    ///            "type": "integer",
    ///            "format": "int64"
    ///          },
    ///          "postBalance": {
    ///            "description": "Balance after the transaction",
    ///            "type": "string"
    ///          },
    ///          "postBalanceInNative": {
    ///            "description": "Balance after in native token",
    ///            "type": "string"
    ///          },
    ///          "postBalanceInUsd": {
    ///            "description": "Balance after in USD",
    ///            "type": "string"
    ///          },
    ///          "preBalance": {
    ///            "description": "Balance before the transaction",
    ///            "type": "string"
    ///          },
    ///          "preBalanceInNative": {
    ///            "description": "Balance before in native token",
    ///            "type": "string"
    ///          },
    ///          "preBalanceInUsd": {
    ///            "description": "Balance before in USD",
    ///            "type": "string"
    ///          },
    ///          "tokenAccountAddress": {
    ///            "description": "Token account address",
    ///            "type": "string"
    ///          },
    ///          "tokenAddress": {
    ///            "description": "Token contract address",
    ///            "type": "string"
    ///          },
    ///          "transactionSignature": {
    ///            "description": "Transaction signature",
    ///            "type": "string"
    ///          },
    ///          "type": {
    ///            "$ref": "#/components/schemas/BalanceTokenType"
    ///          }
    ///        }
    ///      }
    ///    },
    ///    "endCursor": {
    ///      "description": "Cursor for the end of current page",
    ///      "examples": [
    ///        "eyJpZCI6ImVuZCJ9"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "hasNext": {
    ///      "description": "Whether there is a next page",
    ///      "examples": [
    ///        false
    ///      ],
    ///      "type": "boolean"
    ///    },
    ///    "hasPrev": {
    ///      "description": "Whether there is a previous page",
    ///      "examples": [
    ///        false
    ///      ],
    ///      "type": "boolean"
    ///    },
    ///    "startCursor": {
    ///      "description": "Cursor for the start of current page",
    ///      "examples": [
    ///        "eyJpZCI6InN0YXJ0In0="
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct PageResponseBalanceUpdate {
        ///Page data
        pub data: ::std::vec::Vec<PageResponseBalanceUpdateDataItem>,
        ///Cursor for the end of current page
        #[serde(
            rename = "endCursor",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub end_cursor: ::std::option::Option<::std::string::String>,
        ///Whether there is a next page
        #[serde(
            rename = "hasNext",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub has_next: ::std::option::Option<bool>,
        ///Whether there is a previous page
        #[serde(
            rename = "hasPrev",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub has_prev: ::std::option::Option<bool>,
        ///Cursor for the start of current page
        #[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<&PageResponseBalanceUpdate> for PageResponseBalanceUpdate {
        fn from(value: &PageResponseBalanceUpdate) -> Self {
            value.clone()
        }
    }
    impl PageResponseBalanceUpdate {
        pub fn builder() -> builder::PageResponseBalanceUpdate {
            Default::default()
        }
    }
    ///Balance update record
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Balance update record",
    ///  "type": "object",
    ///  "required": [
    ///    "accountOwnerAddress",
    ///    "balanceChange",
    ///    "balanceChangeInNative",
    ///    "balanceChangeInUsd",
    ///    "blockHash",
    ///    "blockHeight",
    ///    "blockTimestamp",
    ///    "changeType",
    ///    "index",
    ///    "postBalance",
    ///    "postBalanceInNative",
    ///    "postBalanceInUsd",
    ///    "preBalance",
    ///    "preBalanceInNative",
    ///    "preBalanceInUsd",
    ///    "tokenAccountAddress",
    ///    "tokenAddress",
    ///    "transactionSignature",
    ///    "type"
    ///  ],
    ///  "properties": {
    ///    "accountOwnerAddress": {
    ///      "description": "Account owner wallet address",
    ///      "type": "string"
    ///    },
    ///    "balanceChange": {
    ///      "description": "Balance change amount",
    ///      "type": "string"
    ///    },
    ///    "balanceChangeInNative": {
    ///      "description": "Balance change in native token",
    ///      "type": "string"
    ///    },
    ///    "balanceChangeInUsd": {
    ///      "description": "Balance change in USD",
    ///      "type": "string"
    ///    },
    ///    "blockHash": {
    ///      "description": "Block hash",
    ///      "type": "string"
    ///    },
    ///    "blockHeight": {
    ///      "description": "Block height",
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "blockSlot": {
    ///      "description": "Block slot number",
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "blockTimestamp": {
    ///      "description": "Block timestamp (milliseconds)",
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "changeType": {
    ///      "$ref": "#/components/schemas/BalanceChangeType"
    ///    },
    ///    "index": {
    ///      "description": "Transaction instruction index",
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "postBalance": {
    ///      "description": "Balance after the transaction",
    ///      "type": "string"
    ///    },
    ///    "postBalanceInNative": {
    ///      "description": "Balance after in native token",
    ///      "type": "string"
    ///    },
    ///    "postBalanceInUsd": {
    ///      "description": "Balance after in USD",
    ///      "type": "string"
    ///    },
    ///    "preBalance": {
    ///      "description": "Balance before the transaction",
    ///      "type": "string"
    ///    },
    ///    "preBalanceInNative": {
    ///      "description": "Balance before in native token",
    ///      "type": "string"
    ///    },
    ///    "preBalanceInUsd": {
    ///      "description": "Balance before in USD",
    ///      "type": "string"
    ///    },
    ///    "tokenAccountAddress": {
    ///      "description": "Token account address",
    ///      "type": "string"
    ///    },
    ///    "tokenAddress": {
    ///      "description": "Token contract address",
    ///      "type": "string"
    ///    },
    ///    "transactionSignature": {
    ///      "description": "Transaction signature",
    ///      "type": "string"
    ///    },
    ///    "type": {
    ///      "$ref": "#/components/schemas/BalanceTokenType"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct PageResponseBalanceUpdateDataItem {
        ///Account owner wallet address
        #[serde(rename = "accountOwnerAddress")]
        pub account_owner_address: ::std::string::String,
        ///Balance change amount
        #[serde(rename = "balanceChange")]
        pub balance_change: ::std::string::String,
        ///Balance change in native token
        #[serde(rename = "balanceChangeInNative")]
        pub balance_change_in_native: ::std::string::String,
        ///Balance change in USD
        #[serde(rename = "balanceChangeInUsd")]
        pub balance_change_in_usd: ::std::string::String,
        ///Block hash
        #[serde(rename = "blockHash")]
        pub block_hash: ::std::string::String,
        ///Block height
        #[serde(rename = "blockHeight")]
        pub block_height: i64,
        ///Block slot number
        #[serde(
            rename = "blockSlot",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub block_slot: ::std::option::Option<i64>,
        ///Block timestamp (milliseconds)
        #[serde(rename = "blockTimestamp")]
        pub block_timestamp: i64,
        #[serde(rename = "changeType")]
        pub change_type: BalanceChangeType,
        ///Transaction instruction index
        pub index: i64,
        ///Balance after the transaction
        #[serde(rename = "postBalance")]
        pub post_balance: ::std::string::String,
        ///Balance after in native token
        #[serde(rename = "postBalanceInNative")]
        pub post_balance_in_native: ::std::string::String,
        ///Balance after in USD
        #[serde(rename = "postBalanceInUsd")]
        pub post_balance_in_usd: ::std::string::String,
        ///Balance before the transaction
        #[serde(rename = "preBalance")]
        pub pre_balance: ::std::string::String,
        ///Balance before in native token
        #[serde(rename = "preBalanceInNative")]
        pub pre_balance_in_native: ::std::string::String,
        ///Balance before in USD
        #[serde(rename = "preBalanceInUsd")]
        pub pre_balance_in_usd: ::std::string::String,
        ///Token account address
        #[serde(rename = "tokenAccountAddress")]
        pub token_account_address: ::std::string::String,
        ///Token contract address
        #[serde(rename = "tokenAddress")]
        pub token_address: ::std::string::String,
        ///Transaction signature
        #[serde(rename = "transactionSignature")]
        pub transaction_signature: ::std::string::String,
        #[serde(rename = "type")]
        pub type_: BalanceTokenType,
    }
    impl ::std::convert::From<&PageResponseBalanceUpdateDataItem>
    for PageResponseBalanceUpdateDataItem {
        fn from(value: &PageResponseBalanceUpdateDataItem) -> Self {
            value.clone()
        }
    }
    impl PageResponseBalanceUpdateDataItem {
        pub fn builder() -> builder::PageResponseBalanceUpdateDataItem {
            Default::default()
        }
    }
    ///Generic pagination response
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Generic pagination response",
    ///  "type": "object",
    ///  "required": [
    ///    "data"
    ///  ],
    ///  "properties": {
    ///    "data": {
    ///      "description": "Page data",
    ///      "type": "array",
    ///      "items": {
    ///        "description": "Token info returned by `get_dev_tokens` — mirrors TS `DevTokenDTO`.",
    ///        "type": "object",
    ///        "required": [
    ///          "address",
    ///          "marketData",
    ///          "metadata",
    ///          "stats"
    ///        ],
    ///        "properties": {
    ///          "address": {
    ///            "description": "Token address",
    ///            "examples": [
    ///              "6p6xgHyF7AeE6TZkSmFsko444wqoP15icUSqi2jfGiPN"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "marketData": {
    ///            "$ref": "#/components/schemas/TokenMarketData"
    ///          },
    ///          "metadata": {
    ///            "$ref": "#/components/schemas/TokenMetadata"
    ///          },
    ///          "stats": {
    ///            "$ref": "#/components/schemas/TokenStats"
    ///          }
    ///        }
    ///      }
    ///    },
    ///    "endCursor": {
    ///      "description": "Cursor for the end of current page",
    ///      "examples": [
    ///        "eyJpZCI6ImVuZCJ9"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "hasNext": {
    ///      "description": "Whether there is a next page",
    ///      "examples": [
    ///        false
    ///      ],
    ///      "type": "boolean"
    ///    },
    ///    "hasPrev": {
    ///      "description": "Whether there is a previous page",
    ///      "examples": [
    ///        false
    ///      ],
    ///      "type": "boolean"
    ///    },
    ///    "startCursor": {
    ///      "description": "Cursor for the start of current page",
    ///      "examples": [
    ///        "eyJpZCI6InN0YXJ0In0="
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct PageResponseDevToken {
        ///Page data
        pub data: ::std::vec::Vec<PageResponseDevTokenDataItem>,
        ///Cursor for the end of current page
        #[serde(
            rename = "endCursor",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub end_cursor: ::std::option::Option<::std::string::String>,
        ///Whether there is a next page
        #[serde(
            rename = "hasNext",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub has_next: ::std::option::Option<bool>,
        ///Whether there is a previous page
        #[serde(
            rename = "hasPrev",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub has_prev: ::std::option::Option<bool>,
        ///Cursor for the start of current page
        #[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<&PageResponseDevToken> for PageResponseDevToken {
        fn from(value: &PageResponseDevToken) -> Self {
            value.clone()
        }
    }
    impl PageResponseDevToken {
        pub fn builder() -> builder::PageResponseDevToken {
            Default::default()
        }
    }
    ///Token info returned by `get_dev_tokens` — mirrors TS `DevTokenDTO`.
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Token info returned by `get_dev_tokens` — mirrors TS `DevTokenDTO`.",
    ///  "type": "object",
    ///  "required": [
    ///    "address",
    ///    "marketData",
    ///    "metadata",
    ///    "stats"
    ///  ],
    ///  "properties": {
    ///    "address": {
    ///      "description": "Token address",
    ///      "examples": [
    ///        "6p6xgHyF7AeE6TZkSmFsko444wqoP15icUSqi2jfGiPN"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "marketData": {
    ///      "$ref": "#/components/schemas/TokenMarketData"
    ///    },
    ///    "metadata": {
    ///      "$ref": "#/components/schemas/TokenMetadata"
    ///    },
    ///    "stats": {
    ///      "$ref": "#/components/schemas/TokenStats"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct PageResponseDevTokenDataItem {
        ///Token address
        pub address: ::std::string::String,
        #[serde(rename = "marketData")]
        pub market_data: TokenMarketData,
        pub metadata: TokenMetadata,
        pub stats: TokenStats,
    }
    impl ::std::convert::From<&PageResponseDevTokenDataItem>
    for PageResponseDevTokenDataItem {
        fn from(value: &PageResponseDevTokenDataItem) -> Self {
            value.clone()
        }
    }
    impl PageResponseDevTokenDataItem {
        pub fn builder() -> builder::PageResponseDevTokenDataItem {
            Default::default()
        }
    }
    ///Generic pagination response
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Generic pagination response",
    ///  "type": "object",
    ///  "required": [
    ///    "data"
    ///  ],
    ///  "properties": {
    ///    "data": {
    ///      "description": "Page data",
    ///      "type": "array",
    ///      "items": {
    ///        "description": "DEX information",
    ///        "type": "object",
    ///        "required": [
    ///          "chain"
    ///        ],
    ///        "properties": {
    ///          "chain": {
    ///            "description": "Chain identifier",
    ///            "examples": [
    ///              "sol"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "image": {
    ///            "description": "DEX image URL",
    ///            "examples": [
    ///              "https://example.com/dex-logo.png"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "programAddress": {
    ///            "description": "DEX program address",
    ///            "examples": [
    ///              "whirLbMiicVdio4qvUfM5KAg6Ct8VwpYzGff3uctyCc"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "protocolFamily": {
    ///            "$ref": "#/components/schemas/DexProtocolFamily"
    ///          }
    ///        }
    ///      }
    ///    },
    ///    "endCursor": {
    ///      "description": "Cursor for the end of current page",
    ///      "examples": [
    ///        "eyJpZCI6ImVuZCJ9"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "hasNext": {
    ///      "description": "Whether there is a next page",
    ///      "examples": [
    ///        false
    ///      ],
    ///      "type": "boolean"
    ///    },
    ///    "hasPrev": {
    ///      "description": "Whether there is a previous page",
    ///      "examples": [
    ///        false
    ///      ],
    ///      "type": "boolean"
    ///    },
    ///    "startCursor": {
    ///      "description": "Cursor for the start of current page",
    ///      "examples": [
    ///        "eyJpZCI6InN0YXJ0In0="
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct PageResponseDex {
        ///Page data
        pub data: ::std::vec::Vec<PageResponseDexDataItem>,
        ///Cursor for the end of current page
        #[serde(
            rename = "endCursor",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub end_cursor: ::std::option::Option<::std::string::String>,
        ///Whether there is a next page
        #[serde(
            rename = "hasNext",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub has_next: ::std::option::Option<bool>,
        ///Whether there is a previous page
        #[serde(
            rename = "hasPrev",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub has_prev: ::std::option::Option<bool>,
        ///Cursor for the start of current page
        #[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<&PageResponseDex> for PageResponseDex {
        fn from(value: &PageResponseDex) -> Self {
            value.clone()
        }
    }
    impl PageResponseDex {
        pub fn builder() -> builder::PageResponseDex {
            Default::default()
        }
    }
    ///DEX information
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "DEX information",
    ///  "type": "object",
    ///  "required": [
    ///    "chain"
    ///  ],
    ///  "properties": {
    ///    "chain": {
    ///      "description": "Chain identifier",
    ///      "examples": [
    ///        "sol"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "image": {
    ///      "description": "DEX image URL",
    ///      "examples": [
    ///        "https://example.com/dex-logo.png"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "programAddress": {
    ///      "description": "DEX program address",
    ///      "examples": [
    ///        "whirLbMiicVdio4qvUfM5KAg6Ct8VwpYzGff3uctyCc"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "protocolFamily": {
    ///      "$ref": "#/components/schemas/DexProtocolFamily"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct PageResponseDexDataItem {
        ///Chain identifier
        pub chain: ::std::string::String,
        ///DEX image URL
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub image: ::std::option::Option<::std::string::String>,
        ///DEX program address
        #[serde(
            rename = "programAddress",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub program_address: ::std::option::Option<::std::string::String>,
        #[serde(
            rename = "protocolFamily",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub protocol_family: ::std::option::Option<DexProtocolFamily>,
    }
    impl ::std::convert::From<&PageResponseDexDataItem> for PageResponseDexDataItem {
        fn from(value: &PageResponseDexDataItem) -> Self {
            value.clone()
        }
    }
    impl PageResponseDexDataItem {
        pub fn builder() -> builder::PageResponseDexDataItem {
            Default::default()
        }
    }
    ///Generic pagination response
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Generic pagination response",
    ///  "type": "object",
    ///  "required": [
    ///    "data"
    ///  ],
    ///  "properties": {
    ///    "data": {
    ///      "description": "Page data",
    ///      "type": "array",
    ///      "items": {
    ///        "description": "DEX pool",
    ///        "type": "object",
    ///        "required": [
    ///          "chain",
    ///          "poolAddress",
    ///          "tokenAAddress",
    ///          "tokenBAddress"
    ///        ],
    ///        "properties": {
    ///          "chain": {
    ///            "description": "Chain",
    ///            "examples": [
    ///              "sol"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "poolAddress": {
    ///            "description": "Pool address",
    ///            "examples": [
    ///              "58oQChx4yWmvKdwLLZzBi4ChoCc2fqCUWBkwMihLYQo2"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "programAddress": {
    ///            "description": "DEX program address",
    ///            "examples": [
    ///              "675kPX9MHTjS2zt1qfr1NYHuzeLXfQM9H24wFSUt1Mp8"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "protocolFamily": {
    ///            "description": "Protocol family",
    ///            "examples": [
    ///              "raydium"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "tokenAAddress": {
    ///            "description": "Token A address",
    ///            "examples": [
    ///              "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "tokenBAddress": {
    ///            "description": "Token B address",
    ///            "examples": [
    ///              "So11111111111111111111111111111111111111112"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "tvlInSol": {
    ///            "description": "TVL in native token",
    ///            "examples": [
    ///              "1000000.45"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "tvlInUsd": {
    ///            "description": "TVL in USD",
    ///            "examples": [
    ///              "1000000.45"
    ///            ],
    ///            "type": "string"
    ///          }
    ///        }
    ///      }
    ///    },
    ///    "endCursor": {
    ///      "description": "Cursor for the end of current page",
    ///      "examples": [
    ///        "eyJpZCI6ImVuZCJ9"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "hasNext": {
    ///      "description": "Whether there is a next page",
    ///      "examples": [
    ///        false
    ///      ],
    ///      "type": "boolean"
    ///    },
    ///    "hasPrev": {
    ///      "description": "Whether there is a previous page",
    ///      "examples": [
    ///        false
    ///      ],
    ///      "type": "boolean"
    ///    },
    ///    "startCursor": {
    ///      "description": "Cursor for the start of current page",
    ///      "examples": [
    ///        "eyJpZCI6InN0YXJ0In0="
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct PageResponseDexPool {
        ///Page data
        pub data: ::std::vec::Vec<PageResponseDexPoolDataItem>,
        ///Cursor for the end of current page
        #[serde(
            rename = "endCursor",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub end_cursor: ::std::option::Option<::std::string::String>,
        ///Whether there is a next page
        #[serde(
            rename = "hasNext",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub has_next: ::std::option::Option<bool>,
        ///Whether there is a previous page
        #[serde(
            rename = "hasPrev",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub has_prev: ::std::option::Option<bool>,
        ///Cursor for the start of current page
        #[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<&PageResponseDexPool> for PageResponseDexPool {
        fn from(value: &PageResponseDexPool) -> Self {
            value.clone()
        }
    }
    impl PageResponseDexPool {
        pub fn builder() -> builder::PageResponseDexPool {
            Default::default()
        }
    }
    ///DEX pool
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "DEX pool",
    ///  "type": "object",
    ///  "required": [
    ///    "chain",
    ///    "poolAddress",
    ///    "tokenAAddress",
    ///    "tokenBAddress"
    ///  ],
    ///  "properties": {
    ///    "chain": {
    ///      "description": "Chain",
    ///      "examples": [
    ///        "sol"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "poolAddress": {
    ///      "description": "Pool address",
    ///      "examples": [
    ///        "58oQChx4yWmvKdwLLZzBi4ChoCc2fqCUWBkwMihLYQo2"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "programAddress": {
    ///      "description": "DEX program address",
    ///      "examples": [
    ///        "675kPX9MHTjS2zt1qfr1NYHuzeLXfQM9H24wFSUt1Mp8"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "protocolFamily": {
    ///      "description": "Protocol family",
    ///      "examples": [
    ///        "raydium"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "tokenAAddress": {
    ///      "description": "Token A address",
    ///      "examples": [
    ///        "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "tokenBAddress": {
    ///      "description": "Token B address",
    ///      "examples": [
    ///        "So11111111111111111111111111111111111111112"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "tvlInSol": {
    ///      "description": "TVL in native token",
    ///      "examples": [
    ///        "1000000.45"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "tvlInUsd": {
    ///      "description": "TVL in USD",
    ///      "examples": [
    ///        "1000000.45"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct PageResponseDexPoolDataItem {
        ///Chain
        pub chain: ::std::string::String,
        ///Pool address
        #[serde(rename = "poolAddress")]
        pub pool_address: ::std::string::String,
        ///DEX program address
        #[serde(
            rename = "programAddress",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub program_address: ::std::option::Option<::std::string::String>,
        ///Protocol family
        #[serde(
            rename = "protocolFamily",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub protocol_family: ::std::option::Option<::std::string::String>,
        ///Token A address
        #[serde(rename = "tokenAAddress")]
        pub token_a_address: ::std::string::String,
        ///Token B address
        #[serde(rename = "tokenBAddress")]
        pub token_b_address: ::std::string::String,
        ///TVL in native token
        #[serde(
            rename = "tvlInSol",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub tvl_in_sol: ::std::option::Option<::std::string::String>,
        ///TVL in USD
        #[serde(
            rename = "tvlInUsd",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub tvl_in_usd: ::std::option::Option<::std::string::String>,
    }
    impl ::std::convert::From<&PageResponseDexPoolDataItem>
    for PageResponseDexPoolDataItem {
        fn from(value: &PageResponseDexPoolDataItem) -> Self {
            value.clone()
        }
    }
    impl PageResponseDexPoolDataItem {
        pub fn builder() -> builder::PageResponseDexPoolDataItem {
            Default::default()
        }
    }
    ///Generic pagination response
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Generic pagination response",
    ///  "type": "object",
    ///  "required": [
    ///    "data"
    ///  ],
    ///  "properties": {
    ///    "data": {
    ///      "description": "Page data",
    ///      "type": "array",
    ///      "items": {
    ///        "description": "DEX pool liquidity snapshot",
    ///        "examples": [
    ///          {
    ///            "blockHeight": 123456789,
    ///            "blockSlot": 123456789,
    ///            "blockTimestamp": 1705312800000,
    ///            "poolAddress": "58oQChx4yWmvKdwLLZzBi4ChoCc2fqCUWBkwMihLYQo2",
    ///            "snapshotTime": 1705312800000,
    ///            "tokenA": {
    ///              "amountInNative": "5000.123",
    ///              "amountInUsd": "1000000.45",
    ///              "decimals": 6,
    ///              "priceNative": "0.005",
    ///              "priceUsd": "1.0001",
    ///              "tokenAddress": "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
    ///              "vaultAmount": "1000000000000"
    ///            },
    ///            "tokenB": {
    ///              "amountInNative": "5000.123",
    ///              "amountInUsd": "1000000.45",
    ///              "decimals": 6,
    ///              "priceNative": "0.005",
    ///              "priceUsd": "1.0001",
    ///              "tokenAddress": "Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB",
    ///              "vaultAmount": "1000000000000"
    ///            },
    ///            "tvlInNative": "5000",
    ///            "tvlInUsd": "1000000.45"
    ///          }
    ///        ],
    ///        "type": "object",
    ///        "required": [
    ///          "blockHeight",
    ///          "blockTimestamp",
    ///          "poolAddress",
    ///          "snapshotTime",
    ///          "tokenA",
    ///          "tokenB",
    ///          "tvlInNative",
    ///          "tvlInUsd"
    ///        ],
    ///        "properties": {
    ///          "blockHeight": {
    ///            "description": "Block height",
    ///            "type": "integer",
    ///            "format": "int64"
    ///          },
    ///          "blockSlot": {
    ///            "description": "Block slot (optional)",
    ///            "type": "integer",
    ///            "format": "int64"
    ///          },
    ///          "blockTimestamp": {
    ///            "description": "Block timestamp (ms)",
    ///            "type": "integer",
    ///            "format": "int64"
    ///          },
    ///          "poolAddress": {
    ///            "description": "Pool address",
    ///            "type": "string"
    ///          },
    ///          "snapshotTime": {
    ///            "description": "Snapshot timestamp (ms)",
    ///            "type": "integer",
    ///            "format": "int64"
    ///          },
    ///          "tokenA": {
    ///            "$ref": "#/components/schemas/DexPoolTokenSnapshot"
    ///          },
    ///          "tokenB": {
    ///            "$ref": "#/components/schemas/DexPoolTokenSnapshot"
    ///          },
    ///          "tvlInNative": {
    ///            "description": "TVL in native token",
    ///            "type": "string"
    ///          },
    ///          "tvlInUsd": {
    ///            "description": "TVL in USD",
    ///            "type": "string"
    ///          }
    ///        }
    ///      }
    ///    },
    ///    "endCursor": {
    ///      "description": "Cursor for the end of current page",
    ///      "examples": [
    ///        "eyJpZCI6ImVuZCJ9"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "hasNext": {
    ///      "description": "Whether there is a next page",
    ///      "examples": [
    ///        false
    ///      ],
    ///      "type": "boolean"
    ///    },
    ///    "hasPrev": {
    ///      "description": "Whether there is a previous page",
    ///      "examples": [
    ///        false
    ///      ],
    ///      "type": "boolean"
    ///    },
    ///    "startCursor": {
    ///      "description": "Cursor for the start of current page",
    ///      "examples": [
    ///        "eyJpZCI6InN0YXJ0In0="
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct PageResponseDexPoolSnapshot {
        ///Page data
        pub data: ::std::vec::Vec<PageResponseDexPoolSnapshotDataItem>,
        ///Cursor for the end of current page
        #[serde(
            rename = "endCursor",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub end_cursor: ::std::option::Option<::std::string::String>,
        ///Whether there is a next page
        #[serde(
            rename = "hasNext",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub has_next: ::std::option::Option<bool>,
        ///Whether there is a previous page
        #[serde(
            rename = "hasPrev",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub has_prev: ::std::option::Option<bool>,
        ///Cursor for the start of current page
        #[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<&PageResponseDexPoolSnapshot>
    for PageResponseDexPoolSnapshot {
        fn from(value: &PageResponseDexPoolSnapshot) -> Self {
            value.clone()
        }
    }
    impl PageResponseDexPoolSnapshot {
        pub fn builder() -> builder::PageResponseDexPoolSnapshot {
            Default::default()
        }
    }
    ///DEX pool liquidity snapshot
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "DEX pool liquidity snapshot",
    ///  "examples": [
    ///    {
    ///      "blockHeight": 123456789,
    ///      "blockSlot": 123456789,
    ///      "blockTimestamp": 1705312800000,
    ///      "poolAddress": "58oQChx4yWmvKdwLLZzBi4ChoCc2fqCUWBkwMihLYQo2",
    ///      "snapshotTime": 1705312800000,
    ///      "tokenA": {
    ///        "amountInNative": "5000.123",
    ///        "amountInUsd": "1000000.45",
    ///        "decimals": 6,
    ///        "priceNative": "0.005",
    ///        "priceUsd": "1.0001",
    ///        "tokenAddress": "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
    ///        "vaultAmount": "1000000000000"
    ///      },
    ///      "tokenB": {
    ///        "amountInNative": "5000.123",
    ///        "amountInUsd": "1000000.45",
    ///        "decimals": 6,
    ///        "priceNative": "0.005",
    ///        "priceUsd": "1.0001",
    ///        "tokenAddress": "Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB",
    ///        "vaultAmount": "1000000000000"
    ///      },
    ///      "tvlInNative": "5000",
    ///      "tvlInUsd": "1000000.45"
    ///    }
    ///  ],
    ///  "type": "object",
    ///  "required": [
    ///    "blockHeight",
    ///    "blockTimestamp",
    ///    "poolAddress",
    ///    "snapshotTime",
    ///    "tokenA",
    ///    "tokenB",
    ///    "tvlInNative",
    ///    "tvlInUsd"
    ///  ],
    ///  "properties": {
    ///    "blockHeight": {
    ///      "description": "Block height",
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "blockSlot": {
    ///      "description": "Block slot (optional)",
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "blockTimestamp": {
    ///      "description": "Block timestamp (ms)",
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "poolAddress": {
    ///      "description": "Pool address",
    ///      "type": "string"
    ///    },
    ///    "snapshotTime": {
    ///      "description": "Snapshot timestamp (ms)",
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "tokenA": {
    ///      "$ref": "#/components/schemas/DexPoolTokenSnapshot"
    ///    },
    ///    "tokenB": {
    ///      "$ref": "#/components/schemas/DexPoolTokenSnapshot"
    ///    },
    ///    "tvlInNative": {
    ///      "description": "TVL in native token",
    ///      "type": "string"
    ///    },
    ///    "tvlInUsd": {
    ///      "description": "TVL in USD",
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct PageResponseDexPoolSnapshotDataItem {
        ///Block height
        #[serde(rename = "blockHeight")]
        pub block_height: i64,
        ///Block slot (optional)
        #[serde(
            rename = "blockSlot",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub block_slot: ::std::option::Option<i64>,
        ///Block timestamp (ms)
        #[serde(rename = "blockTimestamp")]
        pub block_timestamp: i64,
        ///Pool address
        #[serde(rename = "poolAddress")]
        pub pool_address: ::std::string::String,
        ///Snapshot timestamp (ms)
        #[serde(rename = "snapshotTime")]
        pub snapshot_time: i64,
        #[serde(rename = "tokenA")]
        pub token_a: DexPoolTokenSnapshot,
        #[serde(rename = "tokenB")]
        pub token_b: DexPoolTokenSnapshot,
        ///TVL in native token
        #[serde(rename = "tvlInNative")]
        pub tvl_in_native: ::std::string::String,
        ///TVL in USD
        #[serde(rename = "tvlInUsd")]
        pub tvl_in_usd: ::std::string::String,
    }
    impl ::std::convert::From<&PageResponseDexPoolSnapshotDataItem>
    for PageResponseDexPoolSnapshotDataItem {
        fn from(value: &PageResponseDexPoolSnapshotDataItem) -> Self {
            value.clone()
        }
    }
    impl PageResponseDexPoolSnapshotDataItem {
        pub fn builder() -> builder::PageResponseDexPoolSnapshotDataItem {
            Default::default()
        }
    }
    ///Generic pagination response
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Generic pagination response",
    ///  "type": "object",
    ///  "required": [
    ///    "data"
    ///  ],
    ///  "properties": {
    ///    "data": {
    ///      "description": "Page data",
    ///      "type": "array",
    ///      "items": {
    ///        "description": "Single token net-worth item (mirrors TS WalletNetWorthItemDTO).",
    ///        "type": "object",
    ///        "required": [
    ///          "amount",
    ///          "chain",
    ///          "decimals",
    ///          "isActive",
    ///          "name",
    ///          "priceInNative",
    ///          "priceInUsd",
    ///          "symbol",
    ///          "tokenAddress",
    ///          "valueInNative",
    ///          "valueInUsd"
    ///        ],
    ///        "properties": {
    ///          "accuAmount": {
    ///            "description": "Accumulated net token position in token native units:\nbuy_amount - sell_amount + transfer_in_amount - transfer_out_amount.\nMirrors GMGN `accu_amount`. None when all four source fields are absent.",
    ///            "type": "string"
    ///          },
    ///          "amount": {
    ///            "description": "Token holding amount",
    ///            "examples": [
    ///              "1000.50"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "avgCostUsd": {
    ///            "description": "Average cost per token in USD (balance_cost_avg_in_usd; sparse ~0.2% fill rate)",
    ///            "type": "string"
    ///          },
    ///          "chain": {
    ///            "description": "Blockchain network identifier",
    ///            "examples": [
    ///              "sol"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "decimals": {
    ///            "description": "Token decimal places",
    ///            "examples": [
    ///              6
    ///            ],
    ///            "type": "integer",
    ///            "format": "int32"
    ///          },
    ///          "isActive": {
    ///            "description": "Whether the wallet currently holds a non-zero balance",
    ///            "type": "boolean"
    ///          },
    ///          "lastActiveAt": {
    ///            "description": "Last active timestamp (ms since epoch)",
    ///            "type": "integer",
    ///            "format": "int64"
    ///          },
    ///          "logoUri": {
    ///            "description": "Token logo URI",
    ///            "examples": [
    ///              "https://s1.chainstream.io/tokens/images/usdc.webp"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "name": {
    ///            "description": "Token display name",
    ///            "examples": [
    ///              "USD Coin"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "priceInNative": {
    ///            "description": "Token price in native token",
    ///            "examples": [
    ///              "0.00000667"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "priceInUsd": {
    ///            "description": "Token price in USD",
    ///            "examples": [
    ///              "1.0001"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "realizedPnlInUsd": {
    ///            "description": "Realized PnL in USD (all-time cumulative)",
    ///            "type": "string"
    ///          },
    ///          "symbol": {
    ///            "description": "Token ticker symbol",
    ///            "examples": [
    ///              "USDC"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "tokenAddress": {
    ///            "description": "Token contract address",
    ///            "examples": [
    ///              "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "unrealizedPnlInUsd": {
    ///            "description": "Unrealized PnL in USD (current open position)",
    ///            "type": "string"
    ///          },
    ///          "valueInNative": {
    ///            "description": "Holding value in native token",
    ///            "examples": [
    ///              "6.67"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "valueInUsd": {
    ///            "description": "Holding value in USD",
    ///            "examples": [
    ///              "1000.60"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "walletTokenTags": {
    ///            "description": "Trader classification tags",
    ///            "type": "array",
    ///            "items": {
    ///              "type": "string"
    ///            }
    ///          }
    ///        }
    ///      }
    ///    },
    ///    "endCursor": {
    ///      "description": "Cursor for the end of current page",
    ///      "examples": [
    ///        "eyJpZCI6ImVuZCJ9"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "hasNext": {
    ///      "description": "Whether there is a next page",
    ///      "examples": [
    ///        false
    ///      ],
    ///      "type": "boolean"
    ///    },
    ///    "hasPrev": {
    ///      "description": "Whether there is a previous page",
    ///      "examples": [
    ///        false
    ///      ],
    ///      "type": "boolean"
    ///    },
    ///    "startCursor": {
    ///      "description": "Cursor for the start of current page",
    ///      "examples": [
    ///        "eyJpZCI6InN0YXJ0In0="
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct PageResponseNetWorthByTokensItem {
        ///Page data
        pub data: ::std::vec::Vec<PageResponseNetWorthByTokensItemDataItem>,
        ///Cursor for the end of current page
        #[serde(
            rename = "endCursor",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub end_cursor: ::std::option::Option<::std::string::String>,
        ///Whether there is a next page
        #[serde(
            rename = "hasNext",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub has_next: ::std::option::Option<bool>,
        ///Whether there is a previous page
        #[serde(
            rename = "hasPrev",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub has_prev: ::std::option::Option<bool>,
        ///Cursor for the start of current page
        #[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<&PageResponseNetWorthByTokensItem>
    for PageResponseNetWorthByTokensItem {
        fn from(value: &PageResponseNetWorthByTokensItem) -> Self {
            value.clone()
        }
    }
    impl PageResponseNetWorthByTokensItem {
        pub fn builder() -> builder::PageResponseNetWorthByTokensItem {
            Default::default()
        }
    }
    ///Single token net-worth item (mirrors TS WalletNetWorthItemDTO).
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Single token net-worth item (mirrors TS WalletNetWorthItemDTO).",
    ///  "type": "object",
    ///  "required": [
    ///    "amount",
    ///    "chain",
    ///    "decimals",
    ///    "isActive",
    ///    "name",
    ///    "priceInNative",
    ///    "priceInUsd",
    ///    "symbol",
    ///    "tokenAddress",
    ///    "valueInNative",
    ///    "valueInUsd"
    ///  ],
    ///  "properties": {
    ///    "accuAmount": {
    ///      "description": "Accumulated net token position in token native units:\nbuy_amount - sell_amount + transfer_in_amount - transfer_out_amount.\nMirrors GMGN `accu_amount`. None when all four source fields are absent.",
    ///      "type": "string"
    ///    },
    ///    "amount": {
    ///      "description": "Token holding amount",
    ///      "examples": [
    ///        "1000.50"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "avgCostUsd": {
    ///      "description": "Average cost per token in USD (balance_cost_avg_in_usd; sparse ~0.2% fill rate)",
    ///      "type": "string"
    ///    },
    ///    "chain": {
    ///      "description": "Blockchain network identifier",
    ///      "examples": [
    ///        "sol"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "decimals": {
    ///      "description": "Token decimal places",
    ///      "examples": [
    ///        6
    ///      ],
    ///      "type": "integer",
    ///      "format": "int32"
    ///    },
    ///    "isActive": {
    ///      "description": "Whether the wallet currently holds a non-zero balance",
    ///      "type": "boolean"
    ///    },
    ///    "lastActiveAt": {
    ///      "description": "Last active timestamp (ms since epoch)",
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "logoUri": {
    ///      "description": "Token logo URI",
    ///      "examples": [
    ///        "https://s1.chainstream.io/tokens/images/usdc.webp"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "name": {
    ///      "description": "Token display name",
    ///      "examples": [
    ///        "USD Coin"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "priceInNative": {
    ///      "description": "Token price in native token",
    ///      "examples": [
    ///        "0.00000667"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "priceInUsd": {
    ///      "description": "Token price in USD",
    ///      "examples": [
    ///        "1.0001"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "realizedPnlInUsd": {
    ///      "description": "Realized PnL in USD (all-time cumulative)",
    ///      "type": "string"
    ///    },
    ///    "symbol": {
    ///      "description": "Token ticker symbol",
    ///      "examples": [
    ///        "USDC"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "tokenAddress": {
    ///      "description": "Token contract address",
    ///      "examples": [
    ///        "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "unrealizedPnlInUsd": {
    ///      "description": "Unrealized PnL in USD (current open position)",
    ///      "type": "string"
    ///    },
    ///    "valueInNative": {
    ///      "description": "Holding value in native token",
    ///      "examples": [
    ///        "6.67"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "valueInUsd": {
    ///      "description": "Holding value in USD",
    ///      "examples": [
    ///        "1000.60"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "walletTokenTags": {
    ///      "description": "Trader classification tags",
    ///      "type": "array",
    ///      "items": {
    ///        "type": "string"
    ///      }
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct PageResponseNetWorthByTokensItemDataItem {
        /**Accumulated net token position in token native units:
buy_amount - sell_amount + transfer_in_amount - transfer_out_amount.
Mirrors GMGN `accu_amount`. None when all four source fields are absent.*/
        #[serde(
            rename = "accuAmount",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub accu_amount: ::std::option::Option<::std::string::String>,
        ///Token holding amount
        pub amount: ::std::string::String,
        ///Average cost per token in USD (balance_cost_avg_in_usd; sparse ~0.2% fill rate)
        #[serde(
            rename = "avgCostUsd",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub avg_cost_usd: ::std::option::Option<::std::string::String>,
        ///Blockchain network identifier
        pub chain: ::std::string::String,
        ///Token decimal places
        pub decimals: i32,
        ///Whether the wallet currently holds a non-zero balance
        #[serde(rename = "isActive")]
        pub is_active: bool,
        ///Last active timestamp (ms since epoch)
        #[serde(
            rename = "lastActiveAt",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub last_active_at: ::std::option::Option<i64>,
        ///Token logo URI
        #[serde(
            rename = "logoUri",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub logo_uri: ::std::option::Option<::std::string::String>,
        ///Token display name
        pub name: ::std::string::String,
        ///Token price in native token
        #[serde(rename = "priceInNative")]
        pub price_in_native: ::std::string::String,
        ///Token price in USD
        #[serde(rename = "priceInUsd")]
        pub price_in_usd: ::std::string::String,
        ///Realized PnL in USD (all-time cumulative)
        #[serde(
            rename = "realizedPnlInUsd",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub realized_pnl_in_usd: ::std::option::Option<::std::string::String>,
        ///Token ticker symbol
        pub symbol: ::std::string::String,
        ///Token contract address
        #[serde(rename = "tokenAddress")]
        pub token_address: ::std::string::String,
        ///Unrealized PnL in USD (current open position)
        #[serde(
            rename = "unrealizedPnlInUsd",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub unrealized_pnl_in_usd: ::std::option::Option<::std::string::String>,
        ///Holding value in native token
        #[serde(rename = "valueInNative")]
        pub value_in_native: ::std::string::String,
        ///Holding value in USD
        #[serde(rename = "valueInUsd")]
        pub value_in_usd: ::std::string::String,
        ///Trader classification tags
        #[serde(
            rename = "walletTokenTags",
            default,
            skip_serializing_if = "::std::vec::Vec::is_empty"
        )]
        pub wallet_token_tags: ::std::vec::Vec<::std::string::String>,
    }
    impl ::std::convert::From<&PageResponseNetWorthByTokensItemDataItem>
    for PageResponseNetWorthByTokensItemDataItem {
        fn from(value: &PageResponseNetWorthByTokensItemDataItem) -> Self {
            value.clone()
        }
    }
    impl PageResponseNetWorthByTokensItemDataItem {
        pub fn builder() -> builder::PageResponseNetWorthByTokensItemDataItem {
            Default::default()
        }
    }
    ///Generic pagination response
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Generic pagination response",
    ///  "type": "object",
    ///  "required": [
    ///    "data"
    ///  ],
    ///  "properties": {
    ///    "data": {
    ///      "description": "Page data",
    ///      "type": "array",
    ///      "items": {
    ///        "description": "Token entity — mirrors TS `TokenDTO extends TokenMetadataDTO`.\n\nTS uses class inheritance to flatten metadata into the top level.\nRust uses `#[serde(flatten)]` for the same effect.",
    ///        "type": "object",
    ///        "required": [
    ///          "address",
    ///          "chain",
    ///          "decimals",
    ///          "name",
    ///          "symbol"
    ///        ],
    ///        "properties": {
    ///          "address": {
    ///            "description": "Token contract address",
    ///            "examples": [
    ///              "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "chain": {
    ///            "description": "Blockchain network identifier",
    ///            "examples": [
    ///              "sol"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "coingeckoCoinId": {
    ///            "description": "CoinGecko coin identifier",
    ///            "examples": [
    ///              "usd-coin"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "decimals": {
    ///            "description": "Number of decimal places",
    ///            "examples": [
    ///              9
    ///            ],
    ///            "type": "integer",
    ///            "format": "int32"
    ///          },
    ///          "description": {
    ///            "description": "Token description",
    ///            "examples": [
    ///              "USDC is a stablecoin pegged to the US dollar"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "devLastTokenCreatedAt": {
    ///            "description": "Timestamp of developer last token creation",
    ///            "examples": [
    ///              "2025-12-03T09:23:34.000Z"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "devTotalTokens": {
    ///            "description": "Total number of tokens created by the developer",
    ///            "examples": [
    ///              "163"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "extension": {
    ///            "$ref": "#/components/schemas/TokenExtra"
    ///          },
    ///          "extra": {
    ///            "$ref": "#/components/schemas/TokenExtra"
    ///          },
    ///          "imageDup": {
    ///            "description": "ENTITY.TOKEN.IMAGE_DUP",
    ///            "examples": [
    ///              false
    ///            ],
    ///            "type": "boolean"
    ///          },
    ///          "imageHash": {
    ///            "description": "ENTITY.TOKEN.IMAGE_HASH",
    ///            "examples": [
    ///              "a1b2c3d4e5f6a7b8"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "imageUrl": {
    ///            "description": "Token logo image URL",
    ///            "examples": [
    ///              "https://raw.githubusercontent.com/solana-labs/token-list/main/assets/mainnet/EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v/logo.png"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "market": {
    ///            "description": "Trading market identifier",
    ///            "examples": [
    ///              "USDC-SOL"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "marketData": {
    ///            "$ref": "#/components/schemas/TokenMarketData"
    ///          },
    ///          "metadataAddress": {
    ///            "description": "On-chain metadata account address",
    ///            "examples": [
    ///              "metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "name": {
    ///            "description": "Token display name",
    ///            "examples": [
    ///              "USD Coin"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "normalizedName": {
    ///            "description": "ENTITY.TOKEN.NORMALIZED_NAME",
    ///            "examples": [
    ///              "pepe"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "socialMedias": {
    ///            "$ref": "#/components/schemas/TokenSocialMedias"
    ///          },
    ///          "stats": {
    ///            "$ref": "#/components/schemas/TokenStats"
    ///          },
    ///          "symbol": {
    ///            "description": "Token ticker symbol",
    ///            "examples": [
    ///              "USDC"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "tokenCreatedAt": {
    ///            "description": "Token creation timestamp (milliseconds)",
    ///            "examples": [
    ///              1710417600000
    ///            ],
    ///            "type": "integer",
    ///            "format": "int64"
    ///          },
    ///          "tokenCreatedBlockHeight": {
    ///            "description": "Block height when token was created",
    ///            "examples": [
    ///              "220000000"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "tokenCreatedSlot": {
    ///            "description": "Slot number when token was created",
    ///            "examples": [
    ///              "230000000"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "tokenCreatedTxSignature": {
    ///            "description": "Transaction signature of token creation",
    ///            "examples": [
    ///              "5dJ1BxPiFT7w7aBdkxNy2jopGZnZoLwRwS8e9GkEXrVz..."
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "tokenCreators": {
    ///            "description": "List of token creators",
    ///            "type": "array",
    ///            "items": {
    ///              "$ref": "#/components/schemas/TokenCreator"
    ///            }
    ///          },
    ///          "uri": {
    ///            "description": "Token metadata URI",
    ///            "examples": [
    ///              "https://arweave.net/abc123"
    ///            ],
    ///            "type": "string"
    ///          }
    ///        }
    ///      }
    ///    },
    ///    "endCursor": {
    ///      "description": "Cursor for the end of current page",
    ///      "examples": [
    ///        "eyJpZCI6ImVuZCJ9"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "hasNext": {
    ///      "description": "Whether there is a next page",
    ///      "examples": [
    ///        false
    ///      ],
    ///      "type": "boolean"
    ///    },
    ///    "hasPrev": {
    ///      "description": "Whether there is a previous page",
    ///      "examples": [
    ///        false
    ///      ],
    ///      "type": "boolean"
    ///    },
    ///    "startCursor": {
    ///      "description": "Cursor for the start of current page",
    ///      "examples": [
    ///        "eyJpZCI6InN0YXJ0In0="
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct PageResponseToken {
        ///Page data
        pub data: ::std::vec::Vec<PageResponseTokenDataItem>,
        ///Cursor for the end of current page
        #[serde(
            rename = "endCursor",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub end_cursor: ::std::option::Option<::std::string::String>,
        ///Whether there is a next page
        #[serde(
            rename = "hasNext",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub has_next: ::std::option::Option<bool>,
        ///Whether there is a previous page
        #[serde(
            rename = "hasPrev",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub has_prev: ::std::option::Option<bool>,
        ///Cursor for the start of current page
        #[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<&PageResponseToken> for PageResponseToken {
        fn from(value: &PageResponseToken) -> Self {
            value.clone()
        }
    }
    impl PageResponseToken {
        pub fn builder() -> builder::PageResponseToken {
            Default::default()
        }
    }
    /**Token entity — mirrors TS `TokenDTO extends TokenMetadataDTO`.

TS uses class inheritance to flatten metadata into the top level.
Rust uses `#[serde(flatten)]` for the same effect.*/
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Token entity — mirrors TS `TokenDTO extends TokenMetadataDTO`.\n\nTS uses class inheritance to flatten metadata into the top level.\nRust uses `#[serde(flatten)]` for the same effect.",
    ///  "type": "object",
    ///  "required": [
    ///    "address",
    ///    "chain",
    ///    "decimals",
    ///    "name",
    ///    "symbol"
    ///  ],
    ///  "properties": {
    ///    "address": {
    ///      "description": "Token contract address",
    ///      "examples": [
    ///        "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "chain": {
    ///      "description": "Blockchain network identifier",
    ///      "examples": [
    ///        "sol"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "coingeckoCoinId": {
    ///      "description": "CoinGecko coin identifier",
    ///      "examples": [
    ///        "usd-coin"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "decimals": {
    ///      "description": "Number of decimal places",
    ///      "examples": [
    ///        9
    ///      ],
    ///      "type": "integer",
    ///      "format": "int32"
    ///    },
    ///    "description": {
    ///      "description": "Token description",
    ///      "examples": [
    ///        "USDC is a stablecoin pegged to the US dollar"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "devLastTokenCreatedAt": {
    ///      "description": "Timestamp of developer last token creation",
    ///      "examples": [
    ///        "2025-12-03T09:23:34.000Z"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "devTotalTokens": {
    ///      "description": "Total number of tokens created by the developer",
    ///      "examples": [
    ///        "163"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "extension": {
    ///      "$ref": "#/components/schemas/TokenExtra"
    ///    },
    ///    "extra": {
    ///      "$ref": "#/components/schemas/TokenExtra"
    ///    },
    ///    "imageDup": {
    ///      "description": "ENTITY.TOKEN.IMAGE_DUP",
    ///      "examples": [
    ///        false
    ///      ],
    ///      "type": "boolean"
    ///    },
    ///    "imageHash": {
    ///      "description": "ENTITY.TOKEN.IMAGE_HASH",
    ///      "examples": [
    ///        "a1b2c3d4e5f6a7b8"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "imageUrl": {
    ///      "description": "Token logo image URL",
    ///      "examples": [
    ///        "https://raw.githubusercontent.com/solana-labs/token-list/main/assets/mainnet/EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v/logo.png"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "market": {
    ///      "description": "Trading market identifier",
    ///      "examples": [
    ///        "USDC-SOL"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "marketData": {
    ///      "$ref": "#/components/schemas/TokenMarketData"
    ///    },
    ///    "metadataAddress": {
    ///      "description": "On-chain metadata account address",
    ///      "examples": [
    ///        "metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "name": {
    ///      "description": "Token display name",
    ///      "examples": [
    ///        "USD Coin"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "normalizedName": {
    ///      "description": "ENTITY.TOKEN.NORMALIZED_NAME",
    ///      "examples": [
    ///        "pepe"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "socialMedias": {
    ///      "$ref": "#/components/schemas/TokenSocialMedias"
    ///    },
    ///    "stats": {
    ///      "$ref": "#/components/schemas/TokenStats"
    ///    },
    ///    "symbol": {
    ///      "description": "Token ticker symbol",
    ///      "examples": [
    ///        "USDC"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "tokenCreatedAt": {
    ///      "description": "Token creation timestamp (milliseconds)",
    ///      "examples": [
    ///        1710417600000
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "tokenCreatedBlockHeight": {
    ///      "description": "Block height when token was created",
    ///      "examples": [
    ///        "220000000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "tokenCreatedSlot": {
    ///      "description": "Slot number when token was created",
    ///      "examples": [
    ///        "230000000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "tokenCreatedTxSignature": {
    ///      "description": "Transaction signature of token creation",
    ///      "examples": [
    ///        "5dJ1BxPiFT7w7aBdkxNy2jopGZnZoLwRwS8e9GkEXrVz..."
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "tokenCreators": {
    ///      "description": "List of token creators",
    ///      "type": "array",
    ///      "items": {
    ///        "$ref": "#/components/schemas/TokenCreator"
    ///      }
    ///    },
    ///    "uri": {
    ///      "description": "Token metadata URI",
    ///      "examples": [
    ///        "https://arweave.net/abc123"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct PageResponseTokenDataItem {
        ///Token contract address
        pub address: ::std::string::String,
        ///Blockchain network identifier
        pub chain: ::std::string::String,
        ///CoinGecko coin identifier
        #[serde(
            rename = "coingeckoCoinId",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub coingecko_coin_id: ::std::option::Option<::std::string::String>,
        ///Number of decimal places
        pub decimals: i32,
        ///Token description
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub description: ::std::option::Option<::std::string::String>,
        ///Timestamp of developer last token creation
        #[serde(
            rename = "devLastTokenCreatedAt",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub dev_last_token_created_at: ::std::option::Option<::std::string::String>,
        ///Total number of tokens created by the developer
        #[serde(
            rename = "devTotalTokens",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub dev_total_tokens: ::std::option::Option<::std::string::String>,
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub extension: ::std::option::Option<TokenExtra>,
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub extra: ::std::option::Option<TokenExtra>,
        ///ENTITY.TOKEN.IMAGE_DUP
        #[serde(
            rename = "imageDup",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub image_dup: ::std::option::Option<bool>,
        ///ENTITY.TOKEN.IMAGE_HASH
        #[serde(
            rename = "imageHash",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub image_hash: ::std::option::Option<::std::string::String>,
        ///Token logo image URL
        #[serde(
            rename = "imageUrl",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub image_url: ::std::option::Option<::std::string::String>,
        ///Trading market identifier
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub market: ::std::option::Option<::std::string::String>,
        #[serde(
            rename = "marketData",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub market_data: ::std::option::Option<TokenMarketData>,
        ///On-chain metadata account address
        #[serde(
            rename = "metadataAddress",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub metadata_address: ::std::option::Option<::std::string::String>,
        ///Token display name
        pub name: ::std::string::String,
        ///ENTITY.TOKEN.NORMALIZED_NAME
        #[serde(
            rename = "normalizedName",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub normalized_name: ::std::option::Option<::std::string::String>,
        #[serde(
            rename = "socialMedias",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub social_medias: ::std::option::Option<TokenSocialMedias>,
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub stats: ::std::option::Option<TokenStats>,
        ///Token ticker symbol
        pub symbol: ::std::string::String,
        ///Token creation timestamp (milliseconds)
        #[serde(
            rename = "tokenCreatedAt",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub token_created_at: ::std::option::Option<i64>,
        ///Block height when token was created
        #[serde(
            rename = "tokenCreatedBlockHeight",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub token_created_block_height: ::std::option::Option<::std::string::String>,
        ///Slot number when token was created
        #[serde(
            rename = "tokenCreatedSlot",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub token_created_slot: ::std::option::Option<::std::string::String>,
        ///Transaction signature of token creation
        #[serde(
            rename = "tokenCreatedTxSignature",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub token_created_tx_signature: ::std::option::Option<::std::string::String>,
        ///List of token creators
        #[serde(
            rename = "tokenCreators",
            default,
            skip_serializing_if = "::std::vec::Vec::is_empty"
        )]
        pub token_creators: ::std::vec::Vec<TokenCreator>,
        ///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<&PageResponseTokenDataItem> for PageResponseTokenDataItem {
        fn from(value: &PageResponseTokenDataItem) -> Self {
            value.clone()
        }
    }
    impl PageResponseTokenDataItem {
        pub fn builder() -> builder::PageResponseTokenDataItem {
            Default::default()
        }
    }
    ///Generic pagination response
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Generic pagination response",
    ///  "type": "object",
    ///  "required": [
    ///    "data"
    ///  ],
    ///  "properties": {
    ///    "data": {
    ///      "description": "Page data",
    ///      "type": "array",
    ///      "items": {
    ///        "description": "Token holder",
    ///        "type": "object",
    ///        "required": [
    ///          "amount",
    ///          "amountInUsd",
    ///          "percentage",
    ///          "walletAddress"
    ///        ],
    ///        "properties": {
    ///          "accuCost": {
    ///            "description": "Traceable position accumulated cost, USD (GMGN: accu_cost)",
    ///            "type": "string"
    ///          },
    ///          "amount": {
    ///            "description": "Token holding amount",
    ///            "examples": [
    ///              "1000000000000000000"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "amountInUsd": {
    ///            "description": "Token holding value in USD",
    ///            "examples": [
    ///              "1000000000000000000"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "avgBuyPriceUsd": {
    ///            "description": "Average buy price in USD per token (all-time)",
    ///            "type": "string"
    ///          },
    ///          "avgCostUsd": {
    ///            "description": "Average cost per token in USD (current position cost basis)",
    ///            "type": "string"
    ///          },
    ///          "avgSellPriceUsd": {
    ///            "description": "Average sell price in USD per token (all-time)",
    ///            "type": "string"
    ///          },
    ///          "buyAmountCur": {
    ///            "description": "Cumulative token quantity bought, all-time (GMGN: buy_amount_cur / history_bought_amount)",
    ///            "type": "string"
    ///          },
    ///          "buyVolumeNative": {
    ///            "description": "All-time total buy volume in native token",
    ///            "type": "string"
    ///          },
    ///          "buyVolumeUsd": {
    ///            "description": "All-time total buy volume in USD",
    ///            "type": "string"
    ///          },
    ///          "endHoldingAt": {
    ///            "description": "Timestamp when holder fully closed position (ms since epoch)",
    ///            "type": "integer",
    ///            "format": "int64"
    ///          },
    ///          "firstBuyTime": {
    ///            "description": "Timestamp of first token purchase (ms since epoch)",
    ///            "type": "integer",
    ///            "format": "int64"
    ///          },
    ///          "historyBoughtCost": {
    ///            "description": "Total DEX buy cost including fees, USD (GMGN: history_bought_cost)",
    ///            "type": "string"
    ///          },
    ///          "historyBoughtFee": {
    ///            "description": "Total DEX buy fees, USD (GMGN: history_bought_fee)",
    ///            "type": "string"
    ///          },
    ///          "historySoldFee": {
    ///            "description": "Total DEX sell fees, USD (GMGN: history_sold_fee)",
    ///            "type": "string"
    ///          },
    ///          "historySoldIncome": {
    ///            "description": "Total DEX sell income, USD (GMGN: history_sold_income)",
    ///            "type": "string"
    ///          },
    ///          "historyTransferInAmount": {
    ///            "description": "Cumulative transfer-in token qty (GMGN: history_transfer_in_amount)",
    ///            "type": "string"
    ///          },
    ///          "historyTransferInCost": {
    ///            "description": "Transfer-in USD cost basis (GMGN: history_transfer_in_cost)",
    ///            "type": "string"
    ///          },
    ///          "historyTransferOutAmount": {
    ///            "description": "Cumulative transfer-out token qty (GMGN: history_transfer_out_amount)",
    ///            "type": "string"
    ///          },
    ///          "historyTransferOutIncome": {
    ///            "description": "Transfer-out USD income (GMGN: history_transfer_out_income)",
    ///            "type": "string"
    ///          },
    ///          "isClosed": {
    ///            "description": "Whether the token position is fully closed (balance = 0)",
    ///            "type": "boolean"
    ///          },
    ///          "isTransferIn": {
    ///            "description": "Position acquired purely via transfers, no DEX buy (GMGN: transfer_in)",
    ///            "type": "boolean"
    ///          },
    ///          "lastActiveAt": {
    ///            "description": "Last active timestamp (ms since epoch)",
    ///            "type": "integer",
    ///            "format": "int64"
    ///          },
    ///          "lossCount": {
    ///            "description": "Number of losing trades (PnL < 0)",
    ///            "type": "integer",
    ///            "format": "int64"
    ///          },
    ///          "makerTokenTags": {
    ///            "description": "Per-token position/behaviour tags derived at query time.\nPossible values: \"top_holder\" (rank ≤ 10, first page only),\n\"whale\" (holding > $10,000 USD), \"diamond_hands\" (held > 30 days).",
    ///            "type": "array",
    ///            "items": {
    ///              "type": "string"
    ///            }
    ///          },
    ///          "nativeBalance": {
    ///            "description": "Native chain token balance in lamports (SOL) or wei (EVM), as decimal string.\nFetched from RPC with a 10-second Redis cache.",
    ///            "type": "string"
    ///          },
    ///          "netflowUsd": {
    ///            "description": "Net USD inflow (buy_volume_usd − sell_volume_usd); positive = net buyer",
    ///            "type": "string"
    ///          },
    ///          "percentage": {
    ///            "description": "Percentage of total supply held",
    ///            "examples": [
    ///              "100"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "positionCostUsd": {
    ///            "description": "Current open position cost in USD",
    ///            "type": "string"
    ///          },
    ///          "realizedPnlRatio": {
    ///            "description": "Realized PnL / total_cost ratio (GMGN: realized_pnl)",
    ///            "type": "string"
    ///          },
    ///          "realizedProfit": {
    ///            "description": "Realized PnL in USD (all-time)",
    ///            "type": "string"
    ///          },
    ///          "roi": {
    ///            "description": "Return on investment = total_pnl / total_cost_all (e.g. 0.25 = 25%)",
    ///            "type": "string"
    ///          },
    ///          "sellAmountCur": {
    ///            "description": "Cumulative token quantity sold, all-time (GMGN: sell_amount_cur / history_sold_amount)",
    ///            "type": "string"
    ///          },
    ///          "sellAmountPercentage": {
    ///            "description": "Sell quantity / buy quantity, capped 0–1 (GMGN: sell_amount_percentage)",
    ///            "type": "string"
    ///          },
    ///          "sellVolumeNative": {
    ///            "description": "All-time total sell volume in native token",
    ///            "type": "string"
    ///          },
    ///          "sellVolumeUsd": {
    ///            "description": "All-time total sell volume in USD",
    ///            "type": "string"
    ///          },
    ///          "startHoldingAt": {
    ///            "description": "Timestamp when holder first acquired the token (ms since epoch)",
    ///            "type": "integer",
    ///            "format": "int64"
    ///          },
    ///          "tags": {
    ///            "description": "Trader classification tags (e.g. \"kol\", \"smart\", \"sniper\")",
    ///            "type": "array",
    ///            "items": {
    ///              "type": "string"
    ///            }
    ///          },
    ///          "totalBuyCount": {
    ///            "description": "All-time total buy trade count",
    ///            "type": "integer",
    ///            "format": "int64"
    ///          },
    ///          "totalCostUsd": {
    ///            "description": "All-time accumulated cost basis in USD (total_cost_all from pnl-sync)",
    ///            "type": "string"
    ///          },
    ///          "totalProfit": {
    ///            "description": "Total PnL in USD (realized + unrealized)",
    ///            "type": "string"
    ///          },
    ///          "totalSellCount": {
    ///            "description": "All-time total sell trade count",
    ///            "type": "integer",
    ///            "format": "int64"
    ///          },
    ///          "transferInAmount7d": {
    ///            "description": "Inbound transfer volume in native token over last 7 days",
    ///            "type": "string"
    ///          },
    ///          "transferInCount": {
    ///            "description": "Number of token transfer-in events (GMGN: transfer_in_count)",
    ///            "type": "integer",
    ///            "format": "int64"
    ///          },
    ///          "transferOutAmount7d": {
    ///            "description": "Outbound transfer volume in native token over last 7 days",
    ///            "type": "string"
    ///          },
    ///          "transferOutCount": {
    ///            "description": "Number of token transfer-out events (GMGN: transfer_out_count)",
    ///            "type": "integer",
    ///            "format": "int64"
    ///          },
    ///          "unrealizedProfit": {
    ///            "description": "Unrealized PnL in USD (current position)",
    ///            "type": "string"
    ///          },
    ///          "walletAddress": {
    ///            "description": "Holder wallet address",
    ///            "examples": [
    ///              "0x1234567890abcdef"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "walletTagV2": {
    ///            "description": "Global rank tag on this token when sorted by balance (e.g. \"TOP1\", \"TOP2\").\nOnly present on the first page of a balance-sorted query (no cursor).",
    ///            "type": "string"
    ///          },
    ///          "winCount": {
    ///            "description": "Number of winning trades (PnL > 0)",
    ///            "type": "integer",
    ///            "format": "int64"
    ///          }
    ///        }
    ///      }
    ///    },
    ///    "endCursor": {
    ///      "description": "Cursor for the end of current page",
    ///      "examples": [
    ///        "eyJpZCI6ImVuZCJ9"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "hasNext": {
    ///      "description": "Whether there is a next page",
    ///      "examples": [
    ///        false
    ///      ],
    ///      "type": "boolean"
    ///    },
    ///    "hasPrev": {
    ///      "description": "Whether there is a previous page",
    ///      "examples": [
    ///        false
    ///      ],
    ///      "type": "boolean"
    ///    },
    ///    "startCursor": {
    ///      "description": "Cursor for the start of current page",
    ///      "examples": [
    ///        "eyJpZCI6InN0YXJ0In0="
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct PageResponseTokenHolder {
        ///Page data
        pub data: ::std::vec::Vec<PageResponseTokenHolderDataItem>,
        ///Cursor for the end of current page
        #[serde(
            rename = "endCursor",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub end_cursor: ::std::option::Option<::std::string::String>,
        ///Whether there is a next page
        #[serde(
            rename = "hasNext",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub has_next: ::std::option::Option<bool>,
        ///Whether there is a previous page
        #[serde(
            rename = "hasPrev",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub has_prev: ::std::option::Option<bool>,
        ///Cursor for the start of current page
        #[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<&PageResponseTokenHolder> for PageResponseTokenHolder {
        fn from(value: &PageResponseTokenHolder) -> Self {
            value.clone()
        }
    }
    impl PageResponseTokenHolder {
        pub fn builder() -> builder::PageResponseTokenHolder {
            Default::default()
        }
    }
    ///Token holder
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Token holder",
    ///  "type": "object",
    ///  "required": [
    ///    "amount",
    ///    "amountInUsd",
    ///    "percentage",
    ///    "walletAddress"
    ///  ],
    ///  "properties": {
    ///    "accuCost": {
    ///      "description": "Traceable position accumulated cost, USD (GMGN: accu_cost)",
    ///      "type": "string"
    ///    },
    ///    "amount": {
    ///      "description": "Token holding amount",
    ///      "examples": [
    ///        "1000000000000000000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "amountInUsd": {
    ///      "description": "Token holding value in USD",
    ///      "examples": [
    ///        "1000000000000000000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "avgBuyPriceUsd": {
    ///      "description": "Average buy price in USD per token (all-time)",
    ///      "type": "string"
    ///    },
    ///    "avgCostUsd": {
    ///      "description": "Average cost per token in USD (current position cost basis)",
    ///      "type": "string"
    ///    },
    ///    "avgSellPriceUsd": {
    ///      "description": "Average sell price in USD per token (all-time)",
    ///      "type": "string"
    ///    },
    ///    "buyAmountCur": {
    ///      "description": "Cumulative token quantity bought, all-time (GMGN: buy_amount_cur / history_bought_amount)",
    ///      "type": "string"
    ///    },
    ///    "buyVolumeNative": {
    ///      "description": "All-time total buy volume in native token",
    ///      "type": "string"
    ///    },
    ///    "buyVolumeUsd": {
    ///      "description": "All-time total buy volume in USD",
    ///      "type": "string"
    ///    },
    ///    "endHoldingAt": {
    ///      "description": "Timestamp when holder fully closed position (ms since epoch)",
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "firstBuyTime": {
    ///      "description": "Timestamp of first token purchase (ms since epoch)",
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "historyBoughtCost": {
    ///      "description": "Total DEX buy cost including fees, USD (GMGN: history_bought_cost)",
    ///      "type": "string"
    ///    },
    ///    "historyBoughtFee": {
    ///      "description": "Total DEX buy fees, USD (GMGN: history_bought_fee)",
    ///      "type": "string"
    ///    },
    ///    "historySoldFee": {
    ///      "description": "Total DEX sell fees, USD (GMGN: history_sold_fee)",
    ///      "type": "string"
    ///    },
    ///    "historySoldIncome": {
    ///      "description": "Total DEX sell income, USD (GMGN: history_sold_income)",
    ///      "type": "string"
    ///    },
    ///    "historyTransferInAmount": {
    ///      "description": "Cumulative transfer-in token qty (GMGN: history_transfer_in_amount)",
    ///      "type": "string"
    ///    },
    ///    "historyTransferInCost": {
    ///      "description": "Transfer-in USD cost basis (GMGN: history_transfer_in_cost)",
    ///      "type": "string"
    ///    },
    ///    "historyTransferOutAmount": {
    ///      "description": "Cumulative transfer-out token qty (GMGN: history_transfer_out_amount)",
    ///      "type": "string"
    ///    },
    ///    "historyTransferOutIncome": {
    ///      "description": "Transfer-out USD income (GMGN: history_transfer_out_income)",
    ///      "type": "string"
    ///    },
    ///    "isClosed": {
    ///      "description": "Whether the token position is fully closed (balance = 0)",
    ///      "type": "boolean"
    ///    },
    ///    "isTransferIn": {
    ///      "description": "Position acquired purely via transfers, no DEX buy (GMGN: transfer_in)",
    ///      "type": "boolean"
    ///    },
    ///    "lastActiveAt": {
    ///      "description": "Last active timestamp (ms since epoch)",
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "lossCount": {
    ///      "description": "Number of losing trades (PnL < 0)",
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "makerTokenTags": {
    ///      "description": "Per-token position/behaviour tags derived at query time.\nPossible values: \"top_holder\" (rank ≤ 10, first page only),\n\"whale\" (holding > $10,000 USD), \"diamond_hands\" (held > 30 days).",
    ///      "type": "array",
    ///      "items": {
    ///        "type": "string"
    ///      }
    ///    },
    ///    "nativeBalance": {
    ///      "description": "Native chain token balance in lamports (SOL) or wei (EVM), as decimal string.\nFetched from RPC with a 10-second Redis cache.",
    ///      "type": "string"
    ///    },
    ///    "netflowUsd": {
    ///      "description": "Net USD inflow (buy_volume_usd − sell_volume_usd); positive = net buyer",
    ///      "type": "string"
    ///    },
    ///    "percentage": {
    ///      "description": "Percentage of total supply held",
    ///      "examples": [
    ///        "100"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "positionCostUsd": {
    ///      "description": "Current open position cost in USD",
    ///      "type": "string"
    ///    },
    ///    "realizedPnlRatio": {
    ///      "description": "Realized PnL / total_cost ratio (GMGN: realized_pnl)",
    ///      "type": "string"
    ///    },
    ///    "realizedProfit": {
    ///      "description": "Realized PnL in USD (all-time)",
    ///      "type": "string"
    ///    },
    ///    "roi": {
    ///      "description": "Return on investment = total_pnl / total_cost_all (e.g. 0.25 = 25%)",
    ///      "type": "string"
    ///    },
    ///    "sellAmountCur": {
    ///      "description": "Cumulative token quantity sold, all-time (GMGN: sell_amount_cur / history_sold_amount)",
    ///      "type": "string"
    ///    },
    ///    "sellAmountPercentage": {
    ///      "description": "Sell quantity / buy quantity, capped 0–1 (GMGN: sell_amount_percentage)",
    ///      "type": "string"
    ///    },
    ///    "sellVolumeNative": {
    ///      "description": "All-time total sell volume in native token",
    ///      "type": "string"
    ///    },
    ///    "sellVolumeUsd": {
    ///      "description": "All-time total sell volume in USD",
    ///      "type": "string"
    ///    },
    ///    "startHoldingAt": {
    ///      "description": "Timestamp when holder first acquired the token (ms since epoch)",
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "tags": {
    ///      "description": "Trader classification tags (e.g. \"kol\", \"smart\", \"sniper\")",
    ///      "type": "array",
    ///      "items": {
    ///        "type": "string"
    ///      }
    ///    },
    ///    "totalBuyCount": {
    ///      "description": "All-time total buy trade count",
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "totalCostUsd": {
    ///      "description": "All-time accumulated cost basis in USD (total_cost_all from pnl-sync)",
    ///      "type": "string"
    ///    },
    ///    "totalProfit": {
    ///      "description": "Total PnL in USD (realized + unrealized)",
    ///      "type": "string"
    ///    },
    ///    "totalSellCount": {
    ///      "description": "All-time total sell trade count",
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "transferInAmount7d": {
    ///      "description": "Inbound transfer volume in native token over last 7 days",
    ///      "type": "string"
    ///    },
    ///    "transferInCount": {
    ///      "description": "Number of token transfer-in events (GMGN: transfer_in_count)",
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "transferOutAmount7d": {
    ///      "description": "Outbound transfer volume in native token over last 7 days",
    ///      "type": "string"
    ///    },
    ///    "transferOutCount": {
    ///      "description": "Number of token transfer-out events (GMGN: transfer_out_count)",
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "unrealizedProfit": {
    ///      "description": "Unrealized PnL in USD (current position)",
    ///      "type": "string"
    ///    },
    ///    "walletAddress": {
    ///      "description": "Holder wallet address",
    ///      "examples": [
    ///        "0x1234567890abcdef"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "walletTagV2": {
    ///      "description": "Global rank tag on this token when sorted by balance (e.g. \"TOP1\", \"TOP2\").\nOnly present on the first page of a balance-sorted query (no cursor).",
    ///      "type": "string"
    ///    },
    ///    "winCount": {
    ///      "description": "Number of winning trades (PnL > 0)",
    ///      "type": "integer",
    ///      "format": "int64"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct PageResponseTokenHolderDataItem {
        ///Traceable position accumulated cost, USD (GMGN: accu_cost)
        #[serde(
            rename = "accuCost",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub accu_cost: ::std::option::Option<::std::string::String>,
        ///Token holding amount
        pub amount: ::std::string::String,
        ///Token holding value in USD
        #[serde(rename = "amountInUsd")]
        pub amount_in_usd: ::std::string::String,
        ///Average buy price in USD per token (all-time)
        #[serde(
            rename = "avgBuyPriceUsd",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub avg_buy_price_usd: ::std::option::Option<::std::string::String>,
        ///Average cost per token in USD (current position cost basis)
        #[serde(
            rename = "avgCostUsd",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub avg_cost_usd: ::std::option::Option<::std::string::String>,
        ///Average sell price in USD per token (all-time)
        #[serde(
            rename = "avgSellPriceUsd",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub avg_sell_price_usd: ::std::option::Option<::std::string::String>,
        ///Cumulative token quantity bought, all-time (GMGN: buy_amount_cur / history_bought_amount)
        #[serde(
            rename = "buyAmountCur",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub buy_amount_cur: ::std::option::Option<::std::string::String>,
        ///All-time total buy volume in native token
        #[serde(
            rename = "buyVolumeNative",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub buy_volume_native: ::std::option::Option<::std::string::String>,
        ///All-time total buy volume in USD
        #[serde(
            rename = "buyVolumeUsd",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub buy_volume_usd: ::std::option::Option<::std::string::String>,
        ///Timestamp when holder fully closed position (ms since epoch)
        #[serde(
            rename = "endHoldingAt",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub end_holding_at: ::std::option::Option<i64>,
        ///Timestamp of first token purchase (ms since epoch)
        #[serde(
            rename = "firstBuyTime",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub first_buy_time: ::std::option::Option<i64>,
        ///Total DEX buy cost including fees, USD (GMGN: history_bought_cost)
        #[serde(
            rename = "historyBoughtCost",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub history_bought_cost: ::std::option::Option<::std::string::String>,
        ///Total DEX buy fees, USD (GMGN: history_bought_fee)
        #[serde(
            rename = "historyBoughtFee",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub history_bought_fee: ::std::option::Option<::std::string::String>,
        ///Total DEX sell fees, USD (GMGN: history_sold_fee)
        #[serde(
            rename = "historySoldFee",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub history_sold_fee: ::std::option::Option<::std::string::String>,
        ///Total DEX sell income, USD (GMGN: history_sold_income)
        #[serde(
            rename = "historySoldIncome",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub history_sold_income: ::std::option::Option<::std::string::String>,
        ///Cumulative transfer-in token qty (GMGN: history_transfer_in_amount)
        #[serde(
            rename = "historyTransferInAmount",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub history_transfer_in_amount: ::std::option::Option<::std::string::String>,
        ///Transfer-in USD cost basis (GMGN: history_transfer_in_cost)
        #[serde(
            rename = "historyTransferInCost",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub history_transfer_in_cost: ::std::option::Option<::std::string::String>,
        ///Cumulative transfer-out token qty (GMGN: history_transfer_out_amount)
        #[serde(
            rename = "historyTransferOutAmount",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub history_transfer_out_amount: ::std::option::Option<::std::string::String>,
        ///Transfer-out USD income (GMGN: history_transfer_out_income)
        #[serde(
            rename = "historyTransferOutIncome",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub history_transfer_out_income: ::std::option::Option<::std::string::String>,
        ///Whether the token position is fully closed (balance = 0)
        #[serde(
            rename = "isClosed",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub is_closed: ::std::option::Option<bool>,
        ///Position acquired purely via transfers, no DEX buy (GMGN: transfer_in)
        #[serde(
            rename = "isTransferIn",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub is_transfer_in: ::std::option::Option<bool>,
        ///Last active timestamp (ms since epoch)
        #[serde(
            rename = "lastActiveAt",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub last_active_at: ::std::option::Option<i64>,
        ///Number of losing trades (PnL < 0)
        #[serde(
            rename = "lossCount",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub loss_count: ::std::option::Option<i64>,
        /**Per-token position/behaviour tags derived at query time.
Possible values: "top_holder" (rank ≤ 10, first page only),
"whale" (holding > $10,000 USD), "diamond_hands" (held > 30 days).*/
        #[serde(
            rename = "makerTokenTags",
            default,
            skip_serializing_if = "::std::vec::Vec::is_empty"
        )]
        pub maker_token_tags: ::std::vec::Vec<::std::string::String>,
        /**Native chain token balance in lamports (SOL) or wei (EVM), as decimal string.
Fetched from RPC with a 10-second Redis cache.*/
        #[serde(
            rename = "nativeBalance",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub native_balance: ::std::option::Option<::std::string::String>,
        ///Net USD inflow (buy_volume_usd − sell_volume_usd); positive = net buyer
        #[serde(
            rename = "netflowUsd",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub netflow_usd: ::std::option::Option<::std::string::String>,
        ///Percentage of total supply held
        pub percentage: ::std::string::String,
        ///Current open position cost in USD
        #[serde(
            rename = "positionCostUsd",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub position_cost_usd: ::std::option::Option<::std::string::String>,
        ///Realized PnL / total_cost ratio (GMGN: realized_pnl)
        #[serde(
            rename = "realizedPnlRatio",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub realized_pnl_ratio: ::std::option::Option<::std::string::String>,
        ///Realized PnL in USD (all-time)
        #[serde(
            rename = "realizedProfit",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub realized_profit: ::std::option::Option<::std::string::String>,
        ///Return on investment = total_pnl / total_cost_all (e.g. 0.25 = 25%)
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub roi: ::std::option::Option<::std::string::String>,
        ///Cumulative token quantity sold, all-time (GMGN: sell_amount_cur / history_sold_amount)
        #[serde(
            rename = "sellAmountCur",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub sell_amount_cur: ::std::option::Option<::std::string::String>,
        ///Sell quantity / buy quantity, capped 0–1 (GMGN: sell_amount_percentage)
        #[serde(
            rename = "sellAmountPercentage",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub sell_amount_percentage: ::std::option::Option<::std::string::String>,
        ///All-time total sell volume in native token
        #[serde(
            rename = "sellVolumeNative",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub sell_volume_native: ::std::option::Option<::std::string::String>,
        ///All-time total sell volume in USD
        #[serde(
            rename = "sellVolumeUsd",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub sell_volume_usd: ::std::option::Option<::std::string::String>,
        ///Timestamp when holder first acquired the token (ms since epoch)
        #[serde(
            rename = "startHoldingAt",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub start_holding_at: ::std::option::Option<i64>,
        ///Trader classification tags (e.g. "kol", "smart", "sniper")
        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
        pub tags: ::std::vec::Vec<::std::string::String>,
        ///All-time total buy trade count
        #[serde(
            rename = "totalBuyCount",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub total_buy_count: ::std::option::Option<i64>,
        ///All-time accumulated cost basis in USD (total_cost_all from pnl-sync)
        #[serde(
            rename = "totalCostUsd",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub total_cost_usd: ::std::option::Option<::std::string::String>,
        ///Total PnL in USD (realized + unrealized)
        #[serde(
            rename = "totalProfit",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub total_profit: ::std::option::Option<::std::string::String>,
        ///All-time total sell trade count
        #[serde(
            rename = "totalSellCount",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub total_sell_count: ::std::option::Option<i64>,
        ///Inbound transfer volume in native token over last 7 days
        #[serde(
            rename = "transferInAmount7d",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub transfer_in_amount7d: ::std::option::Option<::std::string::String>,
        ///Number of token transfer-in events (GMGN: transfer_in_count)
        #[serde(
            rename = "transferInCount",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub transfer_in_count: ::std::option::Option<i64>,
        ///Outbound transfer volume in native token over last 7 days
        #[serde(
            rename = "transferOutAmount7d",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub transfer_out_amount7d: ::std::option::Option<::std::string::String>,
        ///Number of token transfer-out events (GMGN: transfer_out_count)
        #[serde(
            rename = "transferOutCount",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub transfer_out_count: ::std::option::Option<i64>,
        ///Unrealized PnL in USD (current position)
        #[serde(
            rename = "unrealizedProfit",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub unrealized_profit: ::std::option::Option<::std::string::String>,
        ///Holder wallet address
        #[serde(rename = "walletAddress")]
        pub wallet_address: ::std::string::String,
        /**Global rank tag on this token when sorted by balance (e.g. "TOP1", "TOP2").
Only present on the first page of a balance-sorted query (no cursor).*/
        #[serde(
            rename = "walletTagV2",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub wallet_tag_v2: ::std::option::Option<::std::string::String>,
        ///Number of winning trades (PnL > 0)
        #[serde(
            rename = "winCount",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub win_count: ::std::option::Option<i64>,
    }
    impl ::std::convert::From<&PageResponseTokenHolderDataItem>
    for PageResponseTokenHolderDataItem {
        fn from(value: &PageResponseTokenHolderDataItem) -> Self {
            value.clone()
        }
    }
    impl PageResponseTokenHolderDataItem {
        pub fn builder() -> builder::PageResponseTokenHolderDataItem {
            Default::default()
        }
    }
    ///Generic pagination response
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Generic pagination response",
    ///  "type": "object",
    ///  "required": [
    ///    "data"
    ///  ],
    ///  "properties": {
    ///    "data": {
    ///      "description": "Page data",
    ///      "type": "array",
    ///      "items": {
    ///        "description": "Token liquidity snapshot",
    ///        "type": "object",
    ///        "required": [
    ///          "calculatedAt",
    ///          "maxLiquidityInNative",
    ///          "maxLiquidityInUsd",
    ///          "maxLiquidityPoolAddress",
    ///          "poolCount",
    ///          "priceNative",
    ///          "priceUsd",
    ///          "snapshotTime",
    ///          "totalLiquidityInNative",
    ///          "totalLiquidityInUsd"
    ///        ],
    ///        "properties": {
    ///          "calculatedAt": {
    ///            "description": "Snapshot calculation timestamp (milliseconds)",
    ///            "examples": [
    ///              1705312800000
    ///            ],
    ///            "type": "integer",
    ///            "format": "int64"
    ///          },
    ///          "maxLiquidityInNative": {
    ///            "description": "Maximum pool liquidity in native token",
    ///            "examples": [
    ///              "5000.123"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "maxLiquidityInUsd": {
    ///            "description": "Maximum pool liquidity in USD",
    ///            "examples": [
    ///              "1000000.45"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "maxLiquidityPoolAddress": {
    ///            "description": "Address of the pool with maximum liquidity",
    ///            "examples": [
    ///              "58oQChx4yWmvKdwLLZzBi4ChoCc2fqCUWBkwMihLYQo2"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "poolCount": {
    ///            "description": "Number of active liquidity pools",
    ///            "examples": [
    ///              5
    ///            ],
    ///            "type": "integer",
    ///            "format": "int64"
    ///          },
    ///          "priceNative": {
    ///            "description": "Token price in native token at snapshot time",
    ///            "examples": [
    ///              "0.005"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "priceUsd": {
    ///            "description": "Token price in USD at snapshot time",
    ///            "examples": [
    ///              "1.0001"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "snapshotTime": {
    ///            "description": "Snapshot timestamp (milliseconds)",
    ///            "examples": [
    ///              1705312800000
    ///            ],
    ///            "type": "integer",
    ///            "format": "int64"
    ///          },
    ///          "totalLiquidityInNative": {
    ///            "description": "Total liquidity across all pools in native token",
    ///            "examples": [
    ///              "10000.246"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "totalLiquidityInUsd": {
    ///            "description": "Total liquidity across all pools in USD",
    ///            "examples": [
    ///              "2000000.90"
    ///            ],
    ///            "type": "string"
    ///          }
    ///        }
    ///      }
    ///    },
    ///    "endCursor": {
    ///      "description": "Cursor for the end of current page",
    ///      "examples": [
    ///        "eyJpZCI6ImVuZCJ9"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "hasNext": {
    ///      "description": "Whether there is a next page",
    ///      "examples": [
    ///        false
    ///      ],
    ///      "type": "boolean"
    ///    },
    ///    "hasPrev": {
    ///      "description": "Whether there is a previous page",
    ///      "examples": [
    ///        false
    ///      ],
    ///      "type": "boolean"
    ///    },
    ///    "startCursor": {
    ///      "description": "Cursor for the start of current page",
    ///      "examples": [
    ///        "eyJpZCI6InN0YXJ0In0="
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct PageResponseTokenLiquiditySnapshot {
        ///Page data
        pub data: ::std::vec::Vec<PageResponseTokenLiquiditySnapshotDataItem>,
        ///Cursor for the end of current page
        #[serde(
            rename = "endCursor",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub end_cursor: ::std::option::Option<::std::string::String>,
        ///Whether there is a next page
        #[serde(
            rename = "hasNext",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub has_next: ::std::option::Option<bool>,
        ///Whether there is a previous page
        #[serde(
            rename = "hasPrev",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub has_prev: ::std::option::Option<bool>,
        ///Cursor for the start of current page
        #[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<&PageResponseTokenLiquiditySnapshot>
    for PageResponseTokenLiquiditySnapshot {
        fn from(value: &PageResponseTokenLiquiditySnapshot) -> Self {
            value.clone()
        }
    }
    impl PageResponseTokenLiquiditySnapshot {
        pub fn builder() -> builder::PageResponseTokenLiquiditySnapshot {
            Default::default()
        }
    }
    ///Token liquidity snapshot
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Token liquidity snapshot",
    ///  "type": "object",
    ///  "required": [
    ///    "calculatedAt",
    ///    "maxLiquidityInNative",
    ///    "maxLiquidityInUsd",
    ///    "maxLiquidityPoolAddress",
    ///    "poolCount",
    ///    "priceNative",
    ///    "priceUsd",
    ///    "snapshotTime",
    ///    "totalLiquidityInNative",
    ///    "totalLiquidityInUsd"
    ///  ],
    ///  "properties": {
    ///    "calculatedAt": {
    ///      "description": "Snapshot calculation timestamp (milliseconds)",
    ///      "examples": [
    ///        1705312800000
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "maxLiquidityInNative": {
    ///      "description": "Maximum pool liquidity in native token",
    ///      "examples": [
    ///        "5000.123"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "maxLiquidityInUsd": {
    ///      "description": "Maximum pool liquidity in USD",
    ///      "examples": [
    ///        "1000000.45"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "maxLiquidityPoolAddress": {
    ///      "description": "Address of the pool with maximum liquidity",
    ///      "examples": [
    ///        "58oQChx4yWmvKdwLLZzBi4ChoCc2fqCUWBkwMihLYQo2"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "poolCount": {
    ///      "description": "Number of active liquidity pools",
    ///      "examples": [
    ///        5
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "priceNative": {
    ///      "description": "Token price in native token at snapshot time",
    ///      "examples": [
    ///        "0.005"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "priceUsd": {
    ///      "description": "Token price in USD at snapshot time",
    ///      "examples": [
    ///        "1.0001"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "snapshotTime": {
    ///      "description": "Snapshot timestamp (milliseconds)",
    ///      "examples": [
    ///        1705312800000
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "totalLiquidityInNative": {
    ///      "description": "Total liquidity across all pools in native token",
    ///      "examples": [
    ///        "10000.246"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "totalLiquidityInUsd": {
    ///      "description": "Total liquidity across all pools in USD",
    ///      "examples": [
    ///        "2000000.90"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct PageResponseTokenLiquiditySnapshotDataItem {
        ///Snapshot calculation timestamp (milliseconds)
        #[serde(rename = "calculatedAt")]
        pub calculated_at: i64,
        ///Maximum pool liquidity in native token
        #[serde(rename = "maxLiquidityInNative")]
        pub max_liquidity_in_native: ::std::string::String,
        ///Maximum pool liquidity in USD
        #[serde(rename = "maxLiquidityInUsd")]
        pub max_liquidity_in_usd: ::std::string::String,
        ///Address of the pool with maximum liquidity
        #[serde(rename = "maxLiquidityPoolAddress")]
        pub max_liquidity_pool_address: ::std::string::String,
        ///Number of active liquidity pools
        #[serde(rename = "poolCount")]
        pub pool_count: i64,
        ///Token price in native token at snapshot time
        #[serde(rename = "priceNative")]
        pub price_native: ::std::string::String,
        ///Token price in USD at snapshot time
        #[serde(rename = "priceUsd")]
        pub price_usd: ::std::string::String,
        ///Snapshot timestamp (milliseconds)
        #[serde(rename = "snapshotTime")]
        pub snapshot_time: i64,
        ///Total liquidity across all pools in native token
        #[serde(rename = "totalLiquidityInNative")]
        pub total_liquidity_in_native: ::std::string::String,
        ///Total liquidity across all pools in USD
        #[serde(rename = "totalLiquidityInUsd")]
        pub total_liquidity_in_usd: ::std::string::String,
    }
    impl ::std::convert::From<&PageResponseTokenLiquiditySnapshotDataItem>
    for PageResponseTokenLiquiditySnapshotDataItem {
        fn from(value: &PageResponseTokenLiquiditySnapshotDataItem) -> Self {
            value.clone()
        }
    }
    impl PageResponseTokenLiquiditySnapshotDataItem {
        pub fn builder() -> builder::PageResponseTokenLiquiditySnapshotDataItem {
            Default::default()
        }
    }
    ///Generic pagination response
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Generic pagination response",
    ///  "type": "object",
    ///  "required": [
    ///    "data"
    ///  ],
    ///  "properties": {
    ///    "data": {
    ///      "description": "Page data",
    ///      "type": "array",
    ///      "items": {
    ///        "description": "Token mint/burn event",
    ///        "type": "object",
    ///        "required": [
    ///          "amount",
    ///          "blockHeight",
    ///          "blockTimestamp",
    ///          "mintBurnType",
    ///          "tokenAddress",
    ///          "transactionSignature"
    ///        ],
    ///        "properties": {
    ///          "amount": {
    ///            "description": "Mint/burn amount",
    ///            "examples": [
    ///              "1000000"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "blockHeight": {
    ///            "description": "Block height",
    ///            "examples": [
    ///              123456789
    ///            ],
    ///            "type": "integer",
    ///            "format": "int64"
    ///          },
    ///          "blockTimestamp": {
    ///            "description": "Block timestamp (milliseconds)",
    ///            "examples": [
    ///              1710417600000
    ///            ],
    ///            "type": "integer",
    ///            "format": "int64"
    ///          },
    ///          "mintBurnType": {
    ///            "$ref": "#/components/schemas/MintBurnType"
    ///          },
    ///          "tokenAddress": {
    ///            "description": "Token contract address",
    ///            "examples": [
    ///              "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "transactionSignature": {
    ///            "description": "Transaction signature",
    ///            "examples": [
    ///              "3A7B9C1D2E4F6G8"
    ///            ],
    ///            "type": "string"
    ///          }
    ///        }
    ///      }
    ///    },
    ///    "endCursor": {
    ///      "description": "Cursor for the end of current page",
    ///      "examples": [
    ///        "eyJpZCI6ImVuZCJ9"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "hasNext": {
    ///      "description": "Whether there is a next page",
    ///      "examples": [
    ///        false
    ///      ],
    ///      "type": "boolean"
    ///    },
    ///    "hasPrev": {
    ///      "description": "Whether there is a previous page",
    ///      "examples": [
    ///        false
    ///      ],
    ///      "type": "boolean"
    ///    },
    ///    "startCursor": {
    ///      "description": "Cursor for the start of current page",
    ///      "examples": [
    ///        "eyJpZCI6InN0YXJ0In0="
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct PageResponseTokenMintBurn {
        ///Page data
        pub data: ::std::vec::Vec<PageResponseTokenMintBurnDataItem>,
        ///Cursor for the end of current page
        #[serde(
            rename = "endCursor",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub end_cursor: ::std::option::Option<::std::string::String>,
        ///Whether there is a next page
        #[serde(
            rename = "hasNext",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub has_next: ::std::option::Option<bool>,
        ///Whether there is a previous page
        #[serde(
            rename = "hasPrev",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub has_prev: ::std::option::Option<bool>,
        ///Cursor for the start of current page
        #[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<&PageResponseTokenMintBurn> for PageResponseTokenMintBurn {
        fn from(value: &PageResponseTokenMintBurn) -> Self {
            value.clone()
        }
    }
    impl PageResponseTokenMintBurn {
        pub fn builder() -> builder::PageResponseTokenMintBurn {
            Default::default()
        }
    }
    ///Token mint/burn event
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Token mint/burn event",
    ///  "type": "object",
    ///  "required": [
    ///    "amount",
    ///    "blockHeight",
    ///    "blockTimestamp",
    ///    "mintBurnType",
    ///    "tokenAddress",
    ///    "transactionSignature"
    ///  ],
    ///  "properties": {
    ///    "amount": {
    ///      "description": "Mint/burn amount",
    ///      "examples": [
    ///        "1000000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "blockHeight": {
    ///      "description": "Block height",
    ///      "examples": [
    ///        123456789
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "blockTimestamp": {
    ///      "description": "Block timestamp (milliseconds)",
    ///      "examples": [
    ///        1710417600000
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "mintBurnType": {
    ///      "$ref": "#/components/schemas/MintBurnType"
    ///    },
    ///    "tokenAddress": {
    ///      "description": "Token contract address",
    ///      "examples": [
    ///        "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "transactionSignature": {
    ///      "description": "Transaction signature",
    ///      "examples": [
    ///        "3A7B9C1D2E4F6G8"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct PageResponseTokenMintBurnDataItem {
        ///Mint/burn amount
        pub amount: ::std::string::String,
        ///Block height
        #[serde(rename = "blockHeight")]
        pub block_height: i64,
        ///Block timestamp (milliseconds)
        #[serde(rename = "blockTimestamp")]
        pub block_timestamp: i64,
        #[serde(rename = "mintBurnType")]
        pub mint_burn_type: MintBurnType,
        ///Token contract address
        #[serde(rename = "tokenAddress")]
        pub token_address: ::std::string::String,
        ///Transaction signature
        #[serde(rename = "transactionSignature")]
        pub transaction_signature: ::std::string::String,
    }
    impl ::std::convert::From<&PageResponseTokenMintBurnDataItem>
    for PageResponseTokenMintBurnDataItem {
        fn from(value: &PageResponseTokenMintBurnDataItem) -> Self {
            value.clone()
        }
    }
    impl PageResponseTokenMintBurnDataItem {
        pub fn builder() -> builder::PageResponseTokenMintBurnDataItem {
            Default::default()
        }
    }
    ///Generic pagination response
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Generic pagination response",
    ///  "type": "object",
    ///  "required": [
    ///    "data"
    ///  ],
    ///  "properties": {
    ///    "data": {
    ///      "description": "Page data",
    ///      "type": "array",
    ///      "items": {
    ///        "description": "Token price",
    ///        "type": "object",
    ///        "required": [
    ///          "address",
    ///          "priceInUsd",
    ///          "timestamp"
    ///        ],
    ///        "properties": {
    ///          "address": {
    ///            "description": "Token address",
    ///            "examples": [
    ///              "6p6xgHyF7AeE6TZkSmFsko444wqoP15icUSqi2jfGiPN"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "priceInSol": {
    ///            "description": "Price in native token",
    ///            "examples": [
    ///              "1000"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "priceInUsd": {
    ///            "description": "Price in USD",
    ///            "examples": [
    ///              "1000"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "timestamp": {
    ///            "description": "Timestamp",
    ///            "examples": [
    ///              1754055151000
    ///            ],
    ///            "type": "integer",
    ///            "format": "int64"
    ///          }
    ///        }
    ///      }
    ///    },
    ///    "endCursor": {
    ///      "description": "Cursor for the end of current page",
    ///      "examples": [
    ///        "eyJpZCI6ImVuZCJ9"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "hasNext": {
    ///      "description": "Whether there is a next page",
    ///      "examples": [
    ///        false
    ///      ],
    ///      "type": "boolean"
    ///    },
    ///    "hasPrev": {
    ///      "description": "Whether there is a previous page",
    ///      "examples": [
    ///        false
    ///      ],
    ///      "type": "boolean"
    ///    },
    ///    "startCursor": {
    ///      "description": "Cursor for the start of current page",
    ///      "examples": [
    ///        "eyJpZCI6InN0YXJ0In0="
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct PageResponseTokenPrice {
        ///Page data
        pub data: ::std::vec::Vec<PageResponseTokenPriceDataItem>,
        ///Cursor for the end of current page
        #[serde(
            rename = "endCursor",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub end_cursor: ::std::option::Option<::std::string::String>,
        ///Whether there is a next page
        #[serde(
            rename = "hasNext",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub has_next: ::std::option::Option<bool>,
        ///Whether there is a previous page
        #[serde(
            rename = "hasPrev",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub has_prev: ::std::option::Option<bool>,
        ///Cursor for the start of current page
        #[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<&PageResponseTokenPrice> for PageResponseTokenPrice {
        fn from(value: &PageResponseTokenPrice) -> Self {
            value.clone()
        }
    }
    impl PageResponseTokenPrice {
        pub fn builder() -> builder::PageResponseTokenPrice {
            Default::default()
        }
    }
    ///Token price
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Token price",
    ///  "type": "object",
    ///  "required": [
    ///    "address",
    ///    "priceInUsd",
    ///    "timestamp"
    ///  ],
    ///  "properties": {
    ///    "address": {
    ///      "description": "Token address",
    ///      "examples": [
    ///        "6p6xgHyF7AeE6TZkSmFsko444wqoP15icUSqi2jfGiPN"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "priceInSol": {
    ///      "description": "Price in native token",
    ///      "examples": [
    ///        "1000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "priceInUsd": {
    ///      "description": "Price in USD",
    ///      "examples": [
    ///        "1000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "timestamp": {
    ///      "description": "Timestamp",
    ///      "examples": [
    ///        1754055151000
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct PageResponseTokenPriceDataItem {
        ///Token address
        pub address: ::std::string::String,
        ///Price in native token
        #[serde(
            rename = "priceInSol",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub price_in_sol: ::std::option::Option<::std::string::String>,
        ///Price in USD
        #[serde(rename = "priceInUsd")]
        pub price_in_usd: ::std::string::String,
        ///Timestamp
        pub timestamp: i64,
    }
    impl ::std::convert::From<&PageResponseTokenPriceDataItem>
    for PageResponseTokenPriceDataItem {
        fn from(value: &PageResponseTokenPriceDataItem) -> Self {
            value.clone()
        }
    }
    impl PageResponseTokenPriceDataItem {
        pub fn builder() -> builder::PageResponseTokenPriceDataItem {
            Default::default()
        }
    }
    ///Generic pagination response
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Generic pagination response",
    ///  "type": "object",
    ///  "required": [
    ///    "data"
    ///  ],
    ///  "properties": {
    ///    "data": {
    ///      "description": "Page data",
    ///      "type": "array",
    ///      "items": {
    ///        "description": "Token trader info — mirrors TS `TokenTraderDTO`",
    ///        "type": "object",
    ///        "required": [
    ///          "address"
    ///        ],
    ///        "properties": {
    ///          "address": {
    ///            "description": "Wallet address",
    ///            "examples": [
    ///              "MJKqp326RZCHnAAbew9MDdui3iCKWco7fsK9sVuZTX2"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "blockTimestamp": {
    ///            "description": "Block timestamp (sniper)",
    ///            "examples": [
    ///              "2025-01-15T10:30:00Z"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "onchainCreatedAt": {
    ///            "description": "Onchain account creation time (fresh/dev)",
    ///            "examples": [
    ///              "2025-01-15T10:30:00Z"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "percentileRankTradeAmountInUsd": {
    ///            "description": "Percentile rank of trade amount in USD (pro/insider)",
    ///            "examples": [
    ///              "0.98"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "percentileRankTradeCount": {
    ///            "description": "Percentile rank of trade count (pro)",
    ///            "examples": [
    ///              95
    ///            ],
    ///            "type": "integer",
    ///            "format": "int64"
    ///          },
    ///          "rankTradeAmountInUsd": {
    ///            "description": "Rank trade amount in USD (insider)",
    ///            "examples": [
    ///              "0.95"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "tradeAmountInNative": {
    ///            "description": "Trade amount in native token (pro/insider)",
    ///            "examples": [
    ///              "1500.50"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "tradeAmountInUsd": {
    ///            "description": "Trade amount in USD (pro/insider)",
    ///            "examples": [
    ///              "45000.00"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "tradeCount": {
    ///            "description": "Trade count (pro/insider)",
    ///            "examples": [
    ///              42
    ///            ],
    ///            "type": "integer",
    ///            "format": "int64"
    ///          },
    ///          "transactionSignature": {
    ///            "description": "Transaction signature (sandwish/bundle/sniper)",
    ///            "examples": [
    ///              "5dJ1BxPiFT7w7aBdkxNy2jopGZnZoLwRwS8e9GkEXrVz..."
    ///            ],
    ///            "type": "string"
    ///          }
    ///        }
    ///      }
    ///    },
    ///    "endCursor": {
    ///      "description": "Cursor for the end of current page",
    ///      "examples": [
    ///        "eyJpZCI6ImVuZCJ9"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "hasNext": {
    ///      "description": "Whether there is a next page",
    ///      "examples": [
    ///        false
    ///      ],
    ///      "type": "boolean"
    ///    },
    ///    "hasPrev": {
    ///      "description": "Whether there is a previous page",
    ///      "examples": [
    ///        false
    ///      ],
    ///      "type": "boolean"
    ///    },
    ///    "startCursor": {
    ///      "description": "Cursor for the start of current page",
    ///      "examples": [
    ///        "eyJpZCI6InN0YXJ0In0="
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct PageResponseTokenTrader {
        ///Page data
        pub data: ::std::vec::Vec<PageResponseTokenTraderDataItem>,
        ///Cursor for the end of current page
        #[serde(
            rename = "endCursor",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub end_cursor: ::std::option::Option<::std::string::String>,
        ///Whether there is a next page
        #[serde(
            rename = "hasNext",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub has_next: ::std::option::Option<bool>,
        ///Whether there is a previous page
        #[serde(
            rename = "hasPrev",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub has_prev: ::std::option::Option<bool>,
        ///Cursor for the start of current page
        #[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<&PageResponseTokenTrader> for PageResponseTokenTrader {
        fn from(value: &PageResponseTokenTrader) -> Self {
            value.clone()
        }
    }
    impl PageResponseTokenTrader {
        pub fn builder() -> builder::PageResponseTokenTrader {
            Default::default()
        }
    }
    ///Token trader info — mirrors TS `TokenTraderDTO`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Token trader info — mirrors TS `TokenTraderDTO`",
    ///  "type": "object",
    ///  "required": [
    ///    "address"
    ///  ],
    ///  "properties": {
    ///    "address": {
    ///      "description": "Wallet address",
    ///      "examples": [
    ///        "MJKqp326RZCHnAAbew9MDdui3iCKWco7fsK9sVuZTX2"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "blockTimestamp": {
    ///      "description": "Block timestamp (sniper)",
    ///      "examples": [
    ///        "2025-01-15T10:30:00Z"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "onchainCreatedAt": {
    ///      "description": "Onchain account creation time (fresh/dev)",
    ///      "examples": [
    ///        "2025-01-15T10:30:00Z"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "percentileRankTradeAmountInUsd": {
    ///      "description": "Percentile rank of trade amount in USD (pro/insider)",
    ///      "examples": [
    ///        "0.98"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "percentileRankTradeCount": {
    ///      "description": "Percentile rank of trade count (pro)",
    ///      "examples": [
    ///        95
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "rankTradeAmountInUsd": {
    ///      "description": "Rank trade amount in USD (insider)",
    ///      "examples": [
    ///        "0.95"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "tradeAmountInNative": {
    ///      "description": "Trade amount in native token (pro/insider)",
    ///      "examples": [
    ///        "1500.50"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "tradeAmountInUsd": {
    ///      "description": "Trade amount in USD (pro/insider)",
    ///      "examples": [
    ///        "45000.00"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "tradeCount": {
    ///      "description": "Trade count (pro/insider)",
    ///      "examples": [
    ///        42
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "transactionSignature": {
    ///      "description": "Transaction signature (sandwish/bundle/sniper)",
    ///      "examples": [
    ///        "5dJ1BxPiFT7w7aBdkxNy2jopGZnZoLwRwS8e9GkEXrVz..."
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct PageResponseTokenTraderDataItem {
        ///Wallet address
        pub address: ::std::string::String,
        ///Block timestamp (sniper)
        #[serde(
            rename = "blockTimestamp",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub block_timestamp: ::std::option::Option<::std::string::String>,
        ///Onchain account creation time (fresh/dev)
        #[serde(
            rename = "onchainCreatedAt",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub onchain_created_at: ::std::option::Option<::std::string::String>,
        ///Percentile rank of trade amount in USD (pro/insider)
        #[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,
        >,
        ///Percentile rank of trade count (pro)
        #[serde(
            rename = "percentileRankTradeCount",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub percentile_rank_trade_count: ::std::option::Option<i64>,
        ///Rank trade amount in USD (insider)
        #[serde(
            rename = "rankTradeAmountInUsd",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub rank_trade_amount_in_usd: ::std::option::Option<::std::string::String>,
        ///Trade amount in native token (pro/insider)
        #[serde(
            rename = "tradeAmountInNative",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub trade_amount_in_native: ::std::option::Option<::std::string::String>,
        ///Trade amount in USD (pro/insider)
        #[serde(
            rename = "tradeAmountInUsd",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub trade_amount_in_usd: ::std::option::Option<::std::string::String>,
        ///Trade count (pro/insider)
        #[serde(
            rename = "tradeCount",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub trade_count: ::std::option::Option<i64>,
        ///Transaction signature (sandwish/bundle/sniper)
        #[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<&PageResponseTokenTraderDataItem>
    for PageResponseTokenTraderDataItem {
        fn from(value: &PageResponseTokenTraderDataItem) -> Self {
            value.clone()
        }
    }
    impl PageResponseTokenTraderDataItem {
        pub fn builder() -> builder::PageResponseTokenTraderDataItem {
            Default::default()
        }
    }
    ///Generic pagination response
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Generic pagination response",
    ///  "type": "object",
    ///  "required": [
    ///    "data"
    ///  ],
    ///  "properties": {
    ///    "data": {
    ///      "description": "Page data",
    ///      "type": "array",
    ///      "items": {
    ///        "description": "Token transfer",
    ///        "type": "object",
    ///        "required": [
    ///          "amount",
    ///          "blockTimestamp",
    ///          "fromAddress",
    ///          "id",
    ///          "status",
    ///          "toAddress",
    ///          "tokenAddress",
    ///          "transactionSignature",
    ///          "type"
    ///        ],
    ///        "properties": {
    ///          "amount": {
    ///            "description": "Transfer amount in token units",
    ///            "examples": [
    ///              "1738227.69"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "amountInUsd": {
    ///            "description": "Transfer amount in USD",
    ///            "examples": [
    ///              "4.07"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "blockTimestamp": {
    ///            "description": "Block timestamp (milliseconds)",
    ///            "examples": [
    ///              1710417600000
    ///            ],
    ///            "type": "integer",
    ///            "format": "int64"
    ///          },
    ///          "fromAddress": {
    ///            "description": "Sender address",
    ///            "examples": [
    ///              "3xad3gVnkBLA48PwPApHTu7zSWBV3x6dUfNnBSmMNvn3"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "id": {
    ///            "description": "Transfer record identifier",
    ///            "examples": [
    ///              "transfer-1"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "status": {
    ///            "description": "Transfer status: unknown / succeeded / failed",
    ///            "examples": [
    ///              "succeeded"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "toAddress": {
    ///            "description": "Receiver address",
    ///            "examples": [
    ///              "FgkE7Kwvt4DAU2MbaZmf8ZwKFUUDXR5ownmuYKsUqkxs"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "tokenAddress": {
    ///            "description": "Token contract address",
    ///            "examples": [
    ///              "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "transactionSignature": {
    ///            "description": "Transaction signature",
    ///            "examples": [
    ///              "3hmmomhUcmLMw2ZCqKg5MBfK8b7RBNrBpqvE2Wv7u5V6PCMLh4s7dVfA83NbzNFAgTzVvZuMURoKEviwR92otRp"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "type": {
    ///            "description": "Transfer type: unknown / in / out",
    ///            "examples": [
    ///              "in"
    ///            ],
    ///            "type": "string"
    ///          }
    ///        }
    ///      }
    ///    },
    ///    "endCursor": {
    ///      "description": "Cursor for the end of current page",
    ///      "examples": [
    ///        "eyJpZCI6ImVuZCJ9"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "hasNext": {
    ///      "description": "Whether there is a next page",
    ///      "examples": [
    ///        false
    ///      ],
    ///      "type": "boolean"
    ///    },
    ///    "hasPrev": {
    ///      "description": "Whether there is a previous page",
    ///      "examples": [
    ///        false
    ///      ],
    ///      "type": "boolean"
    ///    },
    ///    "startCursor": {
    ///      "description": "Cursor for the start of current page",
    ///      "examples": [
    ///        "eyJpZCI6InN0YXJ0In0="
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct PageResponseTokenTransfer {
        ///Page data
        pub data: ::std::vec::Vec<PageResponseTokenTransferDataItem>,
        ///Cursor for the end of current page
        #[serde(
            rename = "endCursor",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub end_cursor: ::std::option::Option<::std::string::String>,
        ///Whether there is a next page
        #[serde(
            rename = "hasNext",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub has_next: ::std::option::Option<bool>,
        ///Whether there is a previous page
        #[serde(
            rename = "hasPrev",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub has_prev: ::std::option::Option<bool>,
        ///Cursor for the start of current page
        #[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<&PageResponseTokenTransfer> for PageResponseTokenTransfer {
        fn from(value: &PageResponseTokenTransfer) -> Self {
            value.clone()
        }
    }
    impl PageResponseTokenTransfer {
        pub fn builder() -> builder::PageResponseTokenTransfer {
            Default::default()
        }
    }
    ///Token transfer
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Token transfer",
    ///  "type": "object",
    ///  "required": [
    ///    "amount",
    ///    "blockTimestamp",
    ///    "fromAddress",
    ///    "id",
    ///    "status",
    ///    "toAddress",
    ///    "tokenAddress",
    ///    "transactionSignature",
    ///    "type"
    ///  ],
    ///  "properties": {
    ///    "amount": {
    ///      "description": "Transfer amount in token units",
    ///      "examples": [
    ///        "1738227.69"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "amountInUsd": {
    ///      "description": "Transfer amount in USD",
    ///      "examples": [
    ///        "4.07"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "blockTimestamp": {
    ///      "description": "Block timestamp (milliseconds)",
    ///      "examples": [
    ///        1710417600000
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "fromAddress": {
    ///      "description": "Sender address",
    ///      "examples": [
    ///        "3xad3gVnkBLA48PwPApHTu7zSWBV3x6dUfNnBSmMNvn3"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "id": {
    ///      "description": "Transfer record identifier",
    ///      "examples": [
    ///        "transfer-1"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "status": {
    ///      "description": "Transfer status: unknown / succeeded / failed",
    ///      "examples": [
    ///        "succeeded"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "toAddress": {
    ///      "description": "Receiver address",
    ///      "examples": [
    ///        "FgkE7Kwvt4DAU2MbaZmf8ZwKFUUDXR5ownmuYKsUqkxs"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "tokenAddress": {
    ///      "description": "Token contract address",
    ///      "examples": [
    ///        "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "transactionSignature": {
    ///      "description": "Transaction signature",
    ///      "examples": [
    ///        "3hmmomhUcmLMw2ZCqKg5MBfK8b7RBNrBpqvE2Wv7u5V6PCMLh4s7dVfA83NbzNFAgTzVvZuMURoKEviwR92otRp"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "type": {
    ///      "description": "Transfer type: unknown / in / out",
    ///      "examples": [
    ///        "in"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct PageResponseTokenTransferDataItem {
        ///Transfer amount in token units
        pub amount: ::std::string::String,
        ///Transfer amount in USD
        #[serde(
            rename = "amountInUsd",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub amount_in_usd: ::std::option::Option<::std::string::String>,
        ///Block timestamp (milliseconds)
        #[serde(rename = "blockTimestamp")]
        pub block_timestamp: i64,
        ///Sender address
        #[serde(rename = "fromAddress")]
        pub from_address: ::std::string::String,
        ///Transfer record identifier
        pub id: ::std::string::String,
        ///Transfer status: unknown / succeeded / failed
        pub status: ::std::string::String,
        ///Receiver address
        #[serde(rename = "toAddress")]
        pub to_address: ::std::string::String,
        ///Token contract address
        #[serde(rename = "tokenAddress")]
        pub token_address: ::std::string::String,
        ///Transaction signature
        #[serde(rename = "transactionSignature")]
        pub transaction_signature: ::std::string::String,
        ///Transfer type: unknown / in / out
        #[serde(rename = "type")]
        pub type_: ::std::string::String,
    }
    impl ::std::convert::From<&PageResponseTokenTransferDataItem>
    for PageResponseTokenTransferDataItem {
        fn from(value: &PageResponseTokenTransferDataItem) -> Self {
            value.clone()
        }
    }
    impl PageResponseTokenTransferDataItem {
        pub fn builder() -> builder::PageResponseTokenTransferDataItem {
            Default::default()
        }
    }
    ///Generic pagination response
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Generic pagination response",
    ///  "type": "object",
    ///  "required": [
    ///    "data"
    ///  ],
    ///  "properties": {
    ///    "data": {
    ///      "description": "Page data",
    ///      "type": "array",
    ///      "items": {
    ///        "description": "Top trader statistics",
    ///        "type": "object",
    ///        "required": [
    ///          "buyAmount",
    ///          "buyAmountInNative",
    ///          "buyAmountInUsd",
    ///          "buyCount",
    ///          "sellAmount",
    ///          "sellAmountInNative",
    ///          "sellAmountInUsd",
    ///          "sellCount",
    ///          "tokenAddress",
    ///          "tradeAmount",
    ///          "tradeCount",
    ///          "walletAddress"
    ///        ],
    ///        "properties": {
    ///          "buyAmount": {
    ///            "description": "Total buy amount in token units",
    ///            "examples": [
    ///              "600000"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "buyAmountInNative": {
    ///            "description": "Total buy amount in native token",
    ///            "examples": [
    ///              "100.5"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "buyAmountInUsd": {
    ///            "description": "Total buy amount in USD",
    ///            "examples": [
    ///              "12000.50"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "buyCount": {
    ///            "description": "Number of buy trades",
    ///            "examples": [
    ///              60
    ///            ],
    ///            "type": "integer",
    ///            "format": "int64"
    ///          },
    ///          "sellAmount": {
    ///            "description": "Total sell amount in token units",
    ///            "examples": [
    ///              "400000"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "sellAmountInNative": {
    ///            "description": "Total sell amount in native token",
    ///            "examples": [
    ///              "66.8"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "sellAmountInUsd": {
    ///            "description": "Total sell amount in USD",
    ///            "examples": [
    ///              "8000.30"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "sellCount": {
    ///            "description": "Number of sell trades",
    ///            "examples": [
    ///              40
    ///            ],
    ///            "type": "integer",
    ///            "format": "int64"
    ///          },
    ///          "tokenAddress": {
    ///            "description": "Token contract address",
    ///            "examples": [
    ///              "6p6xgHyF7AeE6TZkSmFsko444wqoP15icUSqi2jfGiPN"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "tradeAmount": {
    ///            "description": "Total trade amount in token units",
    ///            "examples": [
    ///              "1000000"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "tradeCount": {
    ///            "description": "Total number of trades",
    ///            "examples": [
    ///              100
    ///            ],
    ///            "type": "integer",
    ///            "format": "int64"
    ///          },
    ///          "walletAddress": {
    ///            "description": "Trader wallet address",
    ///            "examples": [
    ///              "3xd4LGVWtYXLBspR6X5JWbW49NXmEehfPtX6Kqx98b4w"
    ///            ],
    ///            "type": "string"
    ///          }
    ///        }
    ///      }
    ///    },
    ///    "endCursor": {
    ///      "description": "Cursor for the end of current page",
    ///      "examples": [
    ///        "eyJpZCI6ImVuZCJ9"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "hasNext": {
    ///      "description": "Whether there is a next page",
    ///      "examples": [
    ///        false
    ///      ],
    ///      "type": "boolean"
    ///    },
    ///    "hasPrev": {
    ///      "description": "Whether there is a previous page",
    ///      "examples": [
    ///        false
    ///      ],
    ///      "type": "boolean"
    ///    },
    ///    "startCursor": {
    ///      "description": "Cursor for the start of current page",
    ///      "examples": [
    ///        "eyJpZCI6InN0YXJ0In0="
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct PageResponseTopTrader {
        ///Page data
        pub data: ::std::vec::Vec<PageResponseTopTraderDataItem>,
        ///Cursor for the end of current page
        #[serde(
            rename = "endCursor",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub end_cursor: ::std::option::Option<::std::string::String>,
        ///Whether there is a next page
        #[serde(
            rename = "hasNext",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub has_next: ::std::option::Option<bool>,
        ///Whether there is a previous page
        #[serde(
            rename = "hasPrev",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub has_prev: ::std::option::Option<bool>,
        ///Cursor for the start of current page
        #[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<&PageResponseTopTrader> for PageResponseTopTrader {
        fn from(value: &PageResponseTopTrader) -> Self {
            value.clone()
        }
    }
    impl PageResponseTopTrader {
        pub fn builder() -> builder::PageResponseTopTrader {
            Default::default()
        }
    }
    ///Top trader statistics
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Top trader statistics",
    ///  "type": "object",
    ///  "required": [
    ///    "buyAmount",
    ///    "buyAmountInNative",
    ///    "buyAmountInUsd",
    ///    "buyCount",
    ///    "sellAmount",
    ///    "sellAmountInNative",
    ///    "sellAmountInUsd",
    ///    "sellCount",
    ///    "tokenAddress",
    ///    "tradeAmount",
    ///    "tradeCount",
    ///    "walletAddress"
    ///  ],
    ///  "properties": {
    ///    "buyAmount": {
    ///      "description": "Total buy amount in token units",
    ///      "examples": [
    ///        "600000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "buyAmountInNative": {
    ///      "description": "Total buy amount in native token",
    ///      "examples": [
    ///        "100.5"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "buyAmountInUsd": {
    ///      "description": "Total buy amount in USD",
    ///      "examples": [
    ///        "12000.50"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "buyCount": {
    ///      "description": "Number of buy trades",
    ///      "examples": [
    ///        60
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "sellAmount": {
    ///      "description": "Total sell amount in token units",
    ///      "examples": [
    ///        "400000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "sellAmountInNative": {
    ///      "description": "Total sell amount in native token",
    ///      "examples": [
    ///        "66.8"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "sellAmountInUsd": {
    ///      "description": "Total sell amount in USD",
    ///      "examples": [
    ///        "8000.30"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "sellCount": {
    ///      "description": "Number of sell trades",
    ///      "examples": [
    ///        40
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "tokenAddress": {
    ///      "description": "Token contract address",
    ///      "examples": [
    ///        "6p6xgHyF7AeE6TZkSmFsko444wqoP15icUSqi2jfGiPN"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "tradeAmount": {
    ///      "description": "Total trade amount in token units",
    ///      "examples": [
    ///        "1000000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "tradeCount": {
    ///      "description": "Total number of trades",
    ///      "examples": [
    ///        100
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "walletAddress": {
    ///      "description": "Trader wallet address",
    ///      "examples": [
    ///        "3xd4LGVWtYXLBspR6X5JWbW49NXmEehfPtX6Kqx98b4w"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct PageResponseTopTraderDataItem {
        ///Total buy amount in token units
        #[serde(rename = "buyAmount")]
        pub buy_amount: ::std::string::String,
        ///Total buy amount in native token
        #[serde(rename = "buyAmountInNative")]
        pub buy_amount_in_native: ::std::string::String,
        ///Total buy amount in USD
        #[serde(rename = "buyAmountInUsd")]
        pub buy_amount_in_usd: ::std::string::String,
        ///Number of buy trades
        #[serde(rename = "buyCount")]
        pub buy_count: i64,
        ///Total sell amount in token units
        #[serde(rename = "sellAmount")]
        pub sell_amount: ::std::string::String,
        ///Total sell amount in native token
        #[serde(rename = "sellAmountInNative")]
        pub sell_amount_in_native: ::std::string::String,
        ///Total sell amount in USD
        #[serde(rename = "sellAmountInUsd")]
        pub sell_amount_in_usd: ::std::string::String,
        ///Number of sell trades
        #[serde(rename = "sellCount")]
        pub sell_count: i64,
        ///Token contract address
        #[serde(rename = "tokenAddress")]
        pub token_address: ::std::string::String,
        ///Total trade amount in token units
        #[serde(rename = "tradeAmount")]
        pub trade_amount: ::std::string::String,
        ///Total number of trades
        #[serde(rename = "tradeCount")]
        pub trade_count: i64,
        ///Trader wallet address
        #[serde(rename = "walletAddress")]
        pub wallet_address: ::std::string::String,
    }
    impl ::std::convert::From<&PageResponseTopTraderDataItem>
    for PageResponseTopTraderDataItem {
        fn from(value: &PageResponseTopTraderDataItem) -> Self {
            value.clone()
        }
    }
    impl PageResponseTopTraderDataItem {
        pub fn builder() -> builder::PageResponseTopTraderDataItem {
            Default::default()
        }
    }
    ///Generic pagination response
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Generic pagination response",
    ///  "type": "object",
    ///  "required": [
    ///    "data"
    ///  ],
    ///  "properties": {
    ///    "data": {
    ///      "description": "Page data",
    ///      "type": "array",
    ///      "items": {
    ///        "description": "Trade detail",
    ///        "type": "object",
    ///        "required": [
    ///          "accountOwnerAddress",
    ///          "blockHeight",
    ///          "blockTimestamp",
    ///          "chain",
    ///          "poolAddress",
    ///          "sideTokenAddress",
    ///          "sideTokenAmount",
    ///          "sideTokenAmountInNative",
    ///          "sideTokenAmountInUsd",
    ///          "sideTokenName",
    ///          "sideTokenPriceInNative",
    ///          "sideTokenPriceInUsd",
    ///          "sideTokenSymbol",
    ///          "status",
    ///          "tokenAddress",
    ///          "tokenAmount",
    ///          "tokenAmountInNative",
    ///          "tokenAmountInUsd",
    ///          "tokenName",
    ///          "tokenPriceInNative",
    ///          "tokenPriceInUsd",
    ///          "tokenSymbol",
    ///          "transactionSignature",
    ///          "type"
    ///        ],
    ///        "properties": {
    ///          "accountOwnerAddress": {
    ///            "description": "Account owner address (trader wallet)",
    ///            "examples": [
    ///              "3xd4LGVWtYXLBspR6X5JWbW49NXmEehfPtX6Kqx98b4w"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "blockHeight": {
    ///            "description": "Block height",
    ///            "examples": [
    ///              332417228
    ///            ],
    ///            "type": "integer",
    ///            "format": "int64"
    ///          },
    ///          "blockTimestamp": {
    ///            "description": "Block timestamp (milliseconds)",
    ///            "examples": [
    ///              1717334400000
    ///            ],
    ///            "type": "integer",
    ///            "format": "int64"
    ///          },
    ///          "chain": {
    ///            "description": "Chain identifier",
    ///            "examples": [
    ///              "sol"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "dexImage": {
    ///            "description": "DEX image",
    ///            "examples": [
    ///              "https://example.com/dex.png"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "dexProgramAddress": {
    ///            "description": "DEX program address",
    ///            "examples": [
    ///              "whirLbMiicVdio4qvUfM5KAg6Ct8VwpYzGff3uctyCc"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "dexProtocolFamily": {
    ///            "description": "DEX protocol family",
    ///            "examples": [
    ///              "OrcaWhirpool"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "gasFee": {
    ///            "description": "Gas fee (raw: lamports for SOL, Gwei for BSC)",
    ///            "examples": [
    ///              5000
    ///            ],
    ///            "type": "integer",
    ///            "format": "int64"
    ///          },
    ///          "gasFeeInNative": {
    ///            "description": "Gas fee in native currency (SOL / BNB / ETH)",
    ///            "examples": [
    ///              "0.000073"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "gasFeeInUsd": {
    ///            "description": "Gas fee in USD",
    ///            "examples": [
    ///              "0.011"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "historyBoughtAmount": {
    ///            "description": "Cumulative token quantity bought by this wallet (up to and including this trade).\nMatches GMGN `history_bought_amount`.",
    ///            "type": "string"
    ///          },
    ///          "historySoldAmount": {
    ///            "description": "Cumulative token quantity sold by this wallet (up to and including this trade).\nMatches GMGN `history_sold_amount`.",
    ///            "type": "string"
    ///          },
    ///          "isOpenOrClose": {
    ///            "description": "Position lifecycle: 0=normal, 1=open_position, 2=close_position\nMatches GMGN `is_open_or_close` field.",
    ///            "type": "integer",
    ///            "format": "int32"
    ///          },
    ///          "makerEventTags": {
    ///            "description": "Trade behaviour tags for this event (e.g. \"open_position\", \"dip_buy\",\n\"take_profit\", \"stop_loss\", \"close_position\", \"accumulate\",\n\"transfer_in\", \"transfer_out\").\nMatches GMGN `maker_token_tags` on the activity level.",
    ///            "type": "array",
    ///            "items": {
    ///              "type": "string"
    ///            }
    ///          },
    ///          "marketCapInUsd": {
    ///            "description": "Market cap in USD at trade time",
    ///            "examples": [
    ///              "1500000.00"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "poolAddress": {
    ///            "description": "Pool address",
    ///            "examples": [
    ///              "58oQChx4yWmvKdwLLZzBi4ChoCc2fqCUWBkwMihLYQo2"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "postBalance": {
    ///            "description": "Token balance after this trade (token quantity).\nMatches GMGN `balance` in activity feed.",
    ///            "type": "string"
    ///          },
    ///          "realizedProfitInUsd": {
    ///            "description": "Realized PnL for this specific trade in USD (non-zero only on Sell events).\nMatches GMGN `realized_profit`.",
    ///            "type": "string"
    ///          },
    ///          "sideTokenAddress": {
    ///            "description": "Side token address",
    ///            "examples": [
    ///              "So11111111111111111111111111111111111111112"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "sideTokenAmount": {
    ///            "description": "Side token amount",
    ///            "examples": [
    ///              "1"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "sideTokenAmountInNative": {
    ///            "description": "Side token amount in native currency",
    ///            "examples": [
    ///              "150"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "sideTokenAmountInUsd": {
    ///            "description": "Side token amount in USD",
    ///            "examples": [
    ///              "150"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "sideTokenImageUrl": {
    ///            "description": "Side token image URL",
    ///            "examples": [
    ///              "https://arweave.net/sol.png"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "sideTokenName": {
    ///            "description": "Side token name",
    ///            "examples": [
    ///              "Wrapped SOL"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "sideTokenPriceInNative": {
    ///            "description": "Side token price in native currency",
    ///            "examples": [
    ///              "1"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "sideTokenPriceInUsd": {
    ///            "description": "Side token price in USD",
    ///            "examples": [
    ///              "150"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "sideTokenSymbol": {
    ///            "description": "Side token symbol",
    ///            "examples": [
    ///              "SOL"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "status": {
    ///            "description": "Transaction status",
    ///            "examples": [
    ///              "SUCCEEDED"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "tokenAddress": {
    ///            "description": "Token address",
    ///            "examples": [
    ///              "6p6xgHyF7AeE6TZkSmFsko444wqoP15icUSqi2jfGiPN"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "tokenAmount": {
    ///            "description": "Token amount",
    ///            "examples": [
    ///              "1000000"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "tokenAmountInNative": {
    ///            "description": "Token amount in native currency",
    ///            "examples": [
    ///              "100"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "tokenAmountInUsd": {
    ///            "description": "Token amount in USD",
    ///            "examples": [
    ///              "8800000"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "tokenImageUrl": {
    ///            "description": "Token image URL",
    ///            "examples": [
    ///              "https://arweave.net/token.png"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "tokenName": {
    ///            "description": "Token name",
    ///            "examples": [
    ///              "TRUMP"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "tokenPriceInNative": {
    ///            "description": "Token price in native currency",
    ///            "examples": [
    ///              "0.0001"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "tokenPriceInUsd": {
    ///            "description": "Token price in USD",
    ///            "examples": [
    ///              "8.80"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "tokenSymbol": {
    ///            "description": "Token symbol",
    ///            "examples": [
    ///              "TRUMP"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "traderTags": {
    ///            "description": "Trader classification tags (e.g. \"kol\", \"smart\", \"sniper\", \"dev\", \"bundle\", \"bluechip\")",
    ///            "type": "array",
    ///            "items": {
    ///              "type": "string"
    ///            }
    ///          },
    ///          "transactionSignature": {
    ///            "description": "Transaction signature",
    ///            "examples": [
    ///              "37XpPt9Ak6JiE1V3sftJDtdUsvR9FVFRqkZmoT3dp4BTD9pgyTWn1XgHH6R7NjuJ4pBMAgj8JvZtxQrf4s6NTC5F"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "type": {
    ///            "description": "Trade type (BUY/SELL)",
    ///            "examples": [
    ///              "BUY"
    ///            ],
    ///            "type": "string"
    ///          }
    ///        }
    ///      }
    ///    },
    ///    "endCursor": {
    ///      "description": "Cursor for the end of current page",
    ///      "examples": [
    ///        "eyJpZCI6ImVuZCJ9"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "hasNext": {
    ///      "description": "Whether there is a next page",
    ///      "examples": [
    ///        false
    ///      ],
    ///      "type": "boolean"
    ///    },
    ///    "hasPrev": {
    ///      "description": "Whether there is a previous page",
    ///      "examples": [
    ///        false
    ///      ],
    ///      "type": "boolean"
    ///    },
    ///    "startCursor": {
    ///      "description": "Cursor for the start of current page",
    ///      "examples": [
    ///        "eyJpZCI6InN0YXJ0In0="
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct PageResponseTradeDetail {
        ///Page data
        pub data: ::std::vec::Vec<PageResponseTradeDetailDataItem>,
        ///Cursor for the end of current page
        #[serde(
            rename = "endCursor",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub end_cursor: ::std::option::Option<::std::string::String>,
        ///Whether there is a next page
        #[serde(
            rename = "hasNext",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub has_next: ::std::option::Option<bool>,
        ///Whether there is a previous page
        #[serde(
            rename = "hasPrev",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub has_prev: ::std::option::Option<bool>,
        ///Cursor for the start of current page
        #[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<&PageResponseTradeDetail> for PageResponseTradeDetail {
        fn from(value: &PageResponseTradeDetail) -> Self {
            value.clone()
        }
    }
    impl PageResponseTradeDetail {
        pub fn builder() -> builder::PageResponseTradeDetail {
            Default::default()
        }
    }
    ///Trade detail
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Trade detail",
    ///  "type": "object",
    ///  "required": [
    ///    "accountOwnerAddress",
    ///    "blockHeight",
    ///    "blockTimestamp",
    ///    "chain",
    ///    "poolAddress",
    ///    "sideTokenAddress",
    ///    "sideTokenAmount",
    ///    "sideTokenAmountInNative",
    ///    "sideTokenAmountInUsd",
    ///    "sideTokenName",
    ///    "sideTokenPriceInNative",
    ///    "sideTokenPriceInUsd",
    ///    "sideTokenSymbol",
    ///    "status",
    ///    "tokenAddress",
    ///    "tokenAmount",
    ///    "tokenAmountInNative",
    ///    "tokenAmountInUsd",
    ///    "tokenName",
    ///    "tokenPriceInNative",
    ///    "tokenPriceInUsd",
    ///    "tokenSymbol",
    ///    "transactionSignature",
    ///    "type"
    ///  ],
    ///  "properties": {
    ///    "accountOwnerAddress": {
    ///      "description": "Account owner address (trader wallet)",
    ///      "examples": [
    ///        "3xd4LGVWtYXLBspR6X5JWbW49NXmEehfPtX6Kqx98b4w"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "blockHeight": {
    ///      "description": "Block height",
    ///      "examples": [
    ///        332417228
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "blockTimestamp": {
    ///      "description": "Block timestamp (milliseconds)",
    ///      "examples": [
    ///        1717334400000
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "chain": {
    ///      "description": "Chain identifier",
    ///      "examples": [
    ///        "sol"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "dexImage": {
    ///      "description": "DEX image",
    ///      "examples": [
    ///        "https://example.com/dex.png"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "dexProgramAddress": {
    ///      "description": "DEX program address",
    ///      "examples": [
    ///        "whirLbMiicVdio4qvUfM5KAg6Ct8VwpYzGff3uctyCc"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "dexProtocolFamily": {
    ///      "description": "DEX protocol family",
    ///      "examples": [
    ///        "OrcaWhirpool"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "gasFee": {
    ///      "description": "Gas fee (raw: lamports for SOL, Gwei for BSC)",
    ///      "examples": [
    ///        5000
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "gasFeeInNative": {
    ///      "description": "Gas fee in native currency (SOL / BNB / ETH)",
    ///      "examples": [
    ///        "0.000073"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "gasFeeInUsd": {
    ///      "description": "Gas fee in USD",
    ///      "examples": [
    ///        "0.011"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "historyBoughtAmount": {
    ///      "description": "Cumulative token quantity bought by this wallet (up to and including this trade).\nMatches GMGN `history_bought_amount`.",
    ///      "type": "string"
    ///    },
    ///    "historySoldAmount": {
    ///      "description": "Cumulative token quantity sold by this wallet (up to and including this trade).\nMatches GMGN `history_sold_amount`.",
    ///      "type": "string"
    ///    },
    ///    "isOpenOrClose": {
    ///      "description": "Position lifecycle: 0=normal, 1=open_position, 2=close_position\nMatches GMGN `is_open_or_close` field.",
    ///      "type": "integer",
    ///      "format": "int32"
    ///    },
    ///    "makerEventTags": {
    ///      "description": "Trade behaviour tags for this event (e.g. \"open_position\", \"dip_buy\",\n\"take_profit\", \"stop_loss\", \"close_position\", \"accumulate\",\n\"transfer_in\", \"transfer_out\").\nMatches GMGN `maker_token_tags` on the activity level.",
    ///      "type": "array",
    ///      "items": {
    ///        "type": "string"
    ///      }
    ///    },
    ///    "marketCapInUsd": {
    ///      "description": "Market cap in USD at trade time",
    ///      "examples": [
    ///        "1500000.00"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "poolAddress": {
    ///      "description": "Pool address",
    ///      "examples": [
    ///        "58oQChx4yWmvKdwLLZzBi4ChoCc2fqCUWBkwMihLYQo2"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "postBalance": {
    ///      "description": "Token balance after this trade (token quantity).\nMatches GMGN `balance` in activity feed.",
    ///      "type": "string"
    ///    },
    ///    "realizedProfitInUsd": {
    ///      "description": "Realized PnL for this specific trade in USD (non-zero only on Sell events).\nMatches GMGN `realized_profit`.",
    ///      "type": "string"
    ///    },
    ///    "sideTokenAddress": {
    ///      "description": "Side token address",
    ///      "examples": [
    ///        "So11111111111111111111111111111111111111112"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "sideTokenAmount": {
    ///      "description": "Side token amount",
    ///      "examples": [
    ///        "1"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "sideTokenAmountInNative": {
    ///      "description": "Side token amount in native currency",
    ///      "examples": [
    ///        "150"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "sideTokenAmountInUsd": {
    ///      "description": "Side token amount in USD",
    ///      "examples": [
    ///        "150"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "sideTokenImageUrl": {
    ///      "description": "Side token image URL",
    ///      "examples": [
    ///        "https://arweave.net/sol.png"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "sideTokenName": {
    ///      "description": "Side token name",
    ///      "examples": [
    ///        "Wrapped SOL"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "sideTokenPriceInNative": {
    ///      "description": "Side token price in native currency",
    ///      "examples": [
    ///        "1"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "sideTokenPriceInUsd": {
    ///      "description": "Side token price in USD",
    ///      "examples": [
    ///        "150"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "sideTokenSymbol": {
    ///      "description": "Side token symbol",
    ///      "examples": [
    ///        "SOL"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "status": {
    ///      "description": "Transaction status",
    ///      "examples": [
    ///        "SUCCEEDED"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "tokenAddress": {
    ///      "description": "Token address",
    ///      "examples": [
    ///        "6p6xgHyF7AeE6TZkSmFsko444wqoP15icUSqi2jfGiPN"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "tokenAmount": {
    ///      "description": "Token amount",
    ///      "examples": [
    ///        "1000000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "tokenAmountInNative": {
    ///      "description": "Token amount in native currency",
    ///      "examples": [
    ///        "100"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "tokenAmountInUsd": {
    ///      "description": "Token amount in USD",
    ///      "examples": [
    ///        "8800000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "tokenImageUrl": {
    ///      "description": "Token image URL",
    ///      "examples": [
    ///        "https://arweave.net/token.png"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "tokenName": {
    ///      "description": "Token name",
    ///      "examples": [
    ///        "TRUMP"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "tokenPriceInNative": {
    ///      "description": "Token price in native currency",
    ///      "examples": [
    ///        "0.0001"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "tokenPriceInUsd": {
    ///      "description": "Token price in USD",
    ///      "examples": [
    ///        "8.80"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "tokenSymbol": {
    ///      "description": "Token symbol",
    ///      "examples": [
    ///        "TRUMP"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "traderTags": {
    ///      "description": "Trader classification tags (e.g. \"kol\", \"smart\", \"sniper\", \"dev\", \"bundle\", \"bluechip\")",
    ///      "type": "array",
    ///      "items": {
    ///        "type": "string"
    ///      }
    ///    },
    ///    "transactionSignature": {
    ///      "description": "Transaction signature",
    ///      "examples": [
    ///        "37XpPt9Ak6JiE1V3sftJDtdUsvR9FVFRqkZmoT3dp4BTD9pgyTWn1XgHH6R7NjuJ4pBMAgj8JvZtxQrf4s6NTC5F"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "type": {
    ///      "description": "Trade type (BUY/SELL)",
    ///      "examples": [
    ///        "BUY"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct PageResponseTradeDetailDataItem {
        ///Account owner address (trader wallet)
        #[serde(rename = "accountOwnerAddress")]
        pub account_owner_address: ::std::string::String,
        ///Block height
        #[serde(rename = "blockHeight")]
        pub block_height: i64,
        ///Block timestamp (milliseconds)
        #[serde(rename = "blockTimestamp")]
        pub block_timestamp: i64,
        ///Chain identifier
        pub chain: ::std::string::String,
        ///DEX image
        #[serde(
            rename = "dexImage",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub dex_image: ::std::option::Option<::std::string::String>,
        ///DEX program address
        #[serde(
            rename = "dexProgramAddress",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub dex_program_address: ::std::option::Option<::std::string::String>,
        ///DEX protocol family
        #[serde(
            rename = "dexProtocolFamily",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub dex_protocol_family: ::std::option::Option<::std::string::String>,
        ///Gas fee (raw: lamports for SOL, Gwei for BSC)
        #[serde(
            rename = "gasFee",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub gas_fee: ::std::option::Option<i64>,
        ///Gas fee in native currency (SOL / BNB / ETH)
        #[serde(
            rename = "gasFeeInNative",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub gas_fee_in_native: ::std::option::Option<::std::string::String>,
        ///Gas fee in USD
        #[serde(
            rename = "gasFeeInUsd",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub gas_fee_in_usd: ::std::option::Option<::std::string::String>,
        /**Cumulative token quantity bought by this wallet (up to and including this trade).
Matches GMGN `history_bought_amount`.*/
        #[serde(
            rename = "historyBoughtAmount",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub history_bought_amount: ::std::option::Option<::std::string::String>,
        /**Cumulative token quantity sold by this wallet (up to and including this trade).
Matches GMGN `history_sold_amount`.*/
        #[serde(
            rename = "historySoldAmount",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub history_sold_amount: ::std::option::Option<::std::string::String>,
        /**Position lifecycle: 0=normal, 1=open_position, 2=close_position
Matches GMGN `is_open_or_close` field.*/
        #[serde(
            rename = "isOpenOrClose",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub is_open_or_close: ::std::option::Option<i32>,
        /**Trade behaviour tags for this event (e.g. "open_position", "dip_buy",
"take_profit", "stop_loss", "close_position", "accumulate",
"transfer_in", "transfer_out").
Matches GMGN `maker_token_tags` on the activity level.*/
        #[serde(
            rename = "makerEventTags",
            default,
            skip_serializing_if = "::std::vec::Vec::is_empty"
        )]
        pub maker_event_tags: ::std::vec::Vec<::std::string::String>,
        ///Market cap in USD at trade time
        #[serde(
            rename = "marketCapInUsd",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub market_cap_in_usd: ::std::option::Option<::std::string::String>,
        ///Pool address
        #[serde(rename = "poolAddress")]
        pub pool_address: ::std::string::String,
        /**Token balance after this trade (token quantity).
Matches GMGN `balance` in activity feed.*/
        #[serde(
            rename = "postBalance",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub post_balance: ::std::option::Option<::std::string::String>,
        /**Realized PnL for this specific trade in USD (non-zero only on Sell events).
Matches GMGN `realized_profit`.*/
        #[serde(
            rename = "realizedProfitInUsd",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub realized_profit_in_usd: ::std::option::Option<::std::string::String>,
        ///Side token address
        #[serde(rename = "sideTokenAddress")]
        pub side_token_address: ::std::string::String,
        ///Side token amount
        #[serde(rename = "sideTokenAmount")]
        pub side_token_amount: ::std::string::String,
        ///Side token amount in native currency
        #[serde(rename = "sideTokenAmountInNative")]
        pub side_token_amount_in_native: ::std::string::String,
        ///Side token amount in USD
        #[serde(rename = "sideTokenAmountInUsd")]
        pub side_token_amount_in_usd: ::std::string::String,
        ///Side token image URL
        #[serde(
            rename = "sideTokenImageUrl",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub side_token_image_url: ::std::option::Option<::std::string::String>,
        ///Side token name
        #[serde(rename = "sideTokenName")]
        pub side_token_name: ::std::string::String,
        ///Side token price in native currency
        #[serde(rename = "sideTokenPriceInNative")]
        pub side_token_price_in_native: ::std::string::String,
        ///Side token price in USD
        #[serde(rename = "sideTokenPriceInUsd")]
        pub side_token_price_in_usd: ::std::string::String,
        ///Side token symbol
        #[serde(rename = "sideTokenSymbol")]
        pub side_token_symbol: ::std::string::String,
        ///Transaction status
        pub status: ::std::string::String,
        ///Token address
        #[serde(rename = "tokenAddress")]
        pub token_address: ::std::string::String,
        ///Token amount
        #[serde(rename = "tokenAmount")]
        pub token_amount: ::std::string::String,
        ///Token amount in native currency
        #[serde(rename = "tokenAmountInNative")]
        pub token_amount_in_native: ::std::string::String,
        ///Token amount in USD
        #[serde(rename = "tokenAmountInUsd")]
        pub token_amount_in_usd: ::std::string::String,
        ///Token image URL
        #[serde(
            rename = "tokenImageUrl",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub token_image_url: ::std::option::Option<::std::string::String>,
        ///Token name
        #[serde(rename = "tokenName")]
        pub token_name: ::std::string::String,
        ///Token price in native currency
        #[serde(rename = "tokenPriceInNative")]
        pub token_price_in_native: ::std::string::String,
        ///Token price in USD
        #[serde(rename = "tokenPriceInUsd")]
        pub token_price_in_usd: ::std::string::String,
        ///Token symbol
        #[serde(rename = "tokenSymbol")]
        pub token_symbol: ::std::string::String,
        ///Trader classification tags (e.g. "kol", "smart", "sniper", "dev", "bundle", "bluechip")
        #[serde(
            rename = "traderTags",
            default,
            skip_serializing_if = "::std::vec::Vec::is_empty"
        )]
        pub trader_tags: ::std::vec::Vec<::std::string::String>,
        ///Transaction signature
        #[serde(rename = "transactionSignature")]
        pub transaction_signature: ::std::string::String,
        ///Trade type (BUY/SELL)
        #[serde(rename = "type")]
        pub type_: ::std::string::String,
    }
    impl ::std::convert::From<&PageResponseTradeDetailDataItem>
    for PageResponseTradeDetailDataItem {
        fn from(value: &PageResponseTradeDetailDataItem) -> Self {
            value.clone()
        }
    }
    impl PageResponseTradeDetailDataItem {
        pub fn builder() -> builder::PageResponseTradeDetailDataItem {
            Default::default()
        }
    }
    ///Generic pagination response
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Generic pagination response",
    ///  "type": "object",
    ///  "required": [
    ///    "data"
    ///  ],
    ///  "properties": {
    ///    "data": {
    ///      "description": "Page data",
    ///      "type": "array",
    ///      "items": {
    ///        "description": "Trader gainers/losers item — PnL-based ranking",
    ///        "type": "object",
    ///        "required": [
    ///          "address",
    ///          "chain",
    ///          "pnl",
    ///          "tradeCount",
    ///          "volume"
    ///        ],
    ///        "properties": {
    ///          "address": {
    ///            "description": "Trader wallet address",
    ///            "examples": [
    ///              "3xd4LGVWtYXLBspR6X5JWbW49NXmEehfPtX6Kqx98b4w"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "chain": {
    ///            "description": "Blockchain network identifier",
    ///            "examples": [
    ///              "sol"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "pnl": {
    ///            "description": "Profit and loss amount in USD",
    ///            "examples": [
    ///              "12500.50"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "tradeCount": {
    ///            "description": "Total number of trades",
    ///            "examples": [
    ///              "150"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "volume": {
    ///            "description": "Total trading volume in USD",
    ///            "examples": [
    ///              "85000.00"
    ///            ],
    ///            "type": "string"
    ///          }
    ///        }
    ///      }
    ///    },
    ///    "endCursor": {
    ///      "description": "Cursor for the end of current page",
    ///      "examples": [
    ///        "eyJpZCI6ImVuZCJ9"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "hasNext": {
    ///      "description": "Whether there is a next page",
    ///      "examples": [
    ///        false
    ///      ],
    ///      "type": "boolean"
    ///    },
    ///    "hasPrev": {
    ///      "description": "Whether there is a previous page",
    ///      "examples": [
    ///        false
    ///      ],
    ///      "type": "boolean"
    ///    },
    ///    "startCursor": {
    ///      "description": "Cursor for the start of current page",
    ///      "examples": [
    ///        "eyJpZCI6InN0YXJ0In0="
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct PageResponseTraderGainersLosersItem {
        ///Page data
        pub data: ::std::vec::Vec<PageResponseTraderGainersLosersItemDataItem>,
        ///Cursor for the end of current page
        #[serde(
            rename = "endCursor",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub end_cursor: ::std::option::Option<::std::string::String>,
        ///Whether there is a next page
        #[serde(
            rename = "hasNext",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub has_next: ::std::option::Option<bool>,
        ///Whether there is a previous page
        #[serde(
            rename = "hasPrev",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub has_prev: ::std::option::Option<bool>,
        ///Cursor for the start of current page
        #[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<&PageResponseTraderGainersLosersItem>
    for PageResponseTraderGainersLosersItem {
        fn from(value: &PageResponseTraderGainersLosersItem) -> Self {
            value.clone()
        }
    }
    impl PageResponseTraderGainersLosersItem {
        pub fn builder() -> builder::PageResponseTraderGainersLosersItem {
            Default::default()
        }
    }
    ///Trader gainers/losers item — PnL-based ranking
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Trader gainers/losers item — PnL-based ranking",
    ///  "type": "object",
    ///  "required": [
    ///    "address",
    ///    "chain",
    ///    "pnl",
    ///    "tradeCount",
    ///    "volume"
    ///  ],
    ///  "properties": {
    ///    "address": {
    ///      "description": "Trader wallet address",
    ///      "examples": [
    ///        "3xd4LGVWtYXLBspR6X5JWbW49NXmEehfPtX6Kqx98b4w"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "chain": {
    ///      "description": "Blockchain network identifier",
    ///      "examples": [
    ///        "sol"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "pnl": {
    ///      "description": "Profit and loss amount in USD",
    ///      "examples": [
    ///        "12500.50"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "tradeCount": {
    ///      "description": "Total number of trades",
    ///      "examples": [
    ///        "150"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "volume": {
    ///      "description": "Total trading volume in USD",
    ///      "examples": [
    ///        "85000.00"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct PageResponseTraderGainersLosersItemDataItem {
        ///Trader wallet address
        pub address: ::std::string::String,
        ///Blockchain network identifier
        pub chain: ::std::string::String,
        ///Profit and loss amount in USD
        pub pnl: ::std::string::String,
        ///Total number of trades
        #[serde(rename = "tradeCount")]
        pub trade_count: ::std::string::String,
        ///Total trading volume in USD
        pub volume: ::std::string::String,
    }
    impl ::std::convert::From<&PageResponseTraderGainersLosersItemDataItem>
    for PageResponseTraderGainersLosersItemDataItem {
        fn from(value: &PageResponseTraderGainersLosersItemDataItem) -> Self {
            value.clone()
        }
    }
    impl PageResponseTraderGainersLosersItemDataItem {
        pub fn builder() -> builder::PageResponseTraderGainersLosersItemDataItem {
            Default::default()
        }
    }
    ///Generic pagination response
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Generic pagination response",
    ///  "type": "object",
    ///  "required": [
    ///    "data"
    ///  ],
    ///  "properties": {
    ///    "data": {
    ///      "description": "Page data",
    ///      "type": "array",
    ///      "items": {
    ///        "description": "Wallet transfer",
    ///        "type": "object",
    ///        "required": [
    ///          "amount",
    ///          "blockTimestamp",
    ///          "fromAddress",
    ///          "id",
    ///          "toAddress",
    ///          "tokenAddress",
    ///          "transactionSignature",
    ///          "transferType"
    ///        ],
    ///        "properties": {
    ///          "amount": {
    ///            "description": "Transfer amount in token units",
    ///            "examples": [
    ///              "1.5"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "amountInUsd": {
    ///            "description": "Transfer amount in USD",
    ///            "examples": [
    ///              "225.00"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "blockTimestamp": {
    ///            "description": "Block timestamp (milliseconds)",
    ///            "examples": [
    ///              1717334400000
    ///            ],
    ///            "type": "integer",
    ///            "format": "int64"
    ///          },
    ///          "fromAddress": {
    ///            "description": "Sender address",
    ///            "examples": [
    ///              "54Pz1e35z9uoFdnxtzjp7xZQoFiofqhdayQWBMN7dsuy"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "id": {
    ///            "description": "Transfer record identifier",
    ///            "examples": [
    ///              "transfer-123"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "toAddress": {
    ///            "description": "Receiver address",
    ///            "examples": [
    ///              "8X35rQUK2u9hfn8rMPwwr6ZSEUhbmfDPEapp589XyoM1"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "tokenAddress": {
    ///            "description": "Token contract address",
    ///            "examples": [
    ///              "So11111111111111111111111111111111111111112"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "transactionSignature": {
    ///            "description": "Transaction signature",
    ///            "examples": [
    ///              "4tEHfECrLJm8N7dNCfQSjhLG7LqdMuZhzBhRy7VRhjCt"
    ///            ],
    ///            "type": "string"
    ///          },
    ///          "transferType": {
    ///            "description": "Transfer type (SEND or RECEIVE)",
    ///            "examples": [
    ///              "SEND"
    ///            ],
    ///            "type": "string"
    ///          }
    ///        }
    ///      }
    ///    },
    ///    "endCursor": {
    ///      "description": "Cursor for the end of current page",
    ///      "examples": [
    ///        "eyJpZCI6ImVuZCJ9"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "hasNext": {
    ///      "description": "Whether there is a next page",
    ///      "examples": [
    ///        false
    ///      ],
    ///      "type": "boolean"
    ///    },
    ///    "hasPrev": {
    ///      "description": "Whether there is a previous page",
    ///      "examples": [
    ///        false
    ///      ],
    ///      "type": "boolean"
    ///    },
    ///    "startCursor": {
    ///      "description": "Cursor for the start of current page",
    ///      "examples": [
    ///        "eyJpZCI6InN0YXJ0In0="
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct PageResponseWalletTransfer {
        ///Page data
        pub data: ::std::vec::Vec<PageResponseWalletTransferDataItem>,
        ///Cursor for the end of current page
        #[serde(
            rename = "endCursor",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub end_cursor: ::std::option::Option<::std::string::String>,
        ///Whether there is a next page
        #[serde(
            rename = "hasNext",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub has_next: ::std::option::Option<bool>,
        ///Whether there is a previous page
        #[serde(
            rename = "hasPrev",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub has_prev: ::std::option::Option<bool>,
        ///Cursor for the start of current page
        #[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<&PageResponseWalletTransfer>
    for PageResponseWalletTransfer {
        fn from(value: &PageResponseWalletTransfer) -> Self {
            value.clone()
        }
    }
    impl PageResponseWalletTransfer {
        pub fn builder() -> builder::PageResponseWalletTransfer {
            Default::default()
        }
    }
    ///Wallet transfer
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Wallet transfer",
    ///  "type": "object",
    ///  "required": [
    ///    "amount",
    ///    "blockTimestamp",
    ///    "fromAddress",
    ///    "id",
    ///    "toAddress",
    ///    "tokenAddress",
    ///    "transactionSignature",
    ///    "transferType"
    ///  ],
    ///  "properties": {
    ///    "amount": {
    ///      "description": "Transfer amount in token units",
    ///      "examples": [
    ///        "1.5"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "amountInUsd": {
    ///      "description": "Transfer amount in USD",
    ///      "examples": [
    ///        "225.00"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "blockTimestamp": {
    ///      "description": "Block timestamp (milliseconds)",
    ///      "examples": [
    ///        1717334400000
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "fromAddress": {
    ///      "description": "Sender address",
    ///      "examples": [
    ///        "54Pz1e35z9uoFdnxtzjp7xZQoFiofqhdayQWBMN7dsuy"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "id": {
    ///      "description": "Transfer record identifier",
    ///      "examples": [
    ///        "transfer-123"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "toAddress": {
    ///      "description": "Receiver address",
    ///      "examples": [
    ///        "8X35rQUK2u9hfn8rMPwwr6ZSEUhbmfDPEapp589XyoM1"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "tokenAddress": {
    ///      "description": "Token contract address",
    ///      "examples": [
    ///        "So11111111111111111111111111111111111111112"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "transactionSignature": {
    ///      "description": "Transaction signature",
    ///      "examples": [
    ///        "4tEHfECrLJm8N7dNCfQSjhLG7LqdMuZhzBhRy7VRhjCt"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "transferType": {
    ///      "description": "Transfer type (SEND or RECEIVE)",
    ///      "examples": [
    ///        "SEND"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct PageResponseWalletTransferDataItem {
        ///Transfer amount in token units
        pub amount: ::std::string::String,
        ///Transfer amount in USD
        #[serde(
            rename = "amountInUsd",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub amount_in_usd: ::std::option::Option<::std::string::String>,
        ///Block timestamp (milliseconds)
        #[serde(rename = "blockTimestamp")]
        pub block_timestamp: i64,
        ///Sender address
        #[serde(rename = "fromAddress")]
        pub from_address: ::std::string::String,
        ///Transfer record identifier
        pub id: ::std::string::String,
        ///Receiver address
        #[serde(rename = "toAddress")]
        pub to_address: ::std::string::String,
        ///Token contract address
        #[serde(rename = "tokenAddress")]
        pub token_address: ::std::string::String,
        ///Transaction signature
        #[serde(rename = "transactionSignature")]
        pub transaction_signature: ::std::string::String,
        ///Transfer type (SEND or RECEIVE)
        #[serde(rename = "transferType")]
        pub transfer_type: ::std::string::String,
    }
    impl ::std::convert::From<&PageResponseWalletTransferDataItem>
    for PageResponseWalletTransferDataItem {
        fn from(value: &PageResponseWalletTransferDataItem) -> Self {
            value.clone()
        }
    }
    impl PageResponseWalletTransferDataItem {
        pub fn builder() -> builder::PageResponseWalletTransferDataItem {
            Default::default()
        }
    }
    ///PnL detail for a single wallet-token pair (mirrors TS PnlDetailItemDTO).
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "PnL detail for a single wallet-token pair (mirrors TS PnlDetailItemDTO).",
    ///  "type": "object",
    ///  "required": [
    ///    "avgBuyPriceInUsd",
    ///    "avgProfitPerTradeInUsd",
    ///    "avgSellPriceInUsd",
    ///    "balance",
    ///    "buyAmount",
    ///    "buyAmountInUsd",
    ///    "buys",
    ///    "currentValue",
    ///    "isClosed",
    ///    "priceInUsd",
    ///    "realizedProfitInUsd",
    ///    "realizedProfitRatio",
    ///    "sellAmount",
    ///    "sellAmountInUsd",
    ///    "sells",
    ///    "tokenAddress",
    ///    "totalProfitInUsd",
    ///    "totalProfitRatio",
    ///    "totalTrades",
    ///    "unrealizedProfitInUsd",
    ///    "unrealizedProfitRatio",
    ///    "walletAddress"
    ///  ],
    ///  "properties": {
    ///    "avgBuyPriceInUsd": {
    ///      "description": "Average buy price in USD",
    ///      "examples": [
    ///        "0.00003324391014165111"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "avgProfitPerTradeInUsd": {
    ///      "description": "Average profit per trade in USD",
    ///      "examples": [
    ///        "3206068.5728287027967835484926836364"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "avgSellPriceInUsd": {
    ///      "description": "Average sell price in USD",
    ///      "examples": [
    ///        "0.00003185807445122603"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "balance": {
    ///      "description": "Current token balance",
    ///      "examples": [
    ///        "1254982158.7106050000000000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "buyAmount": {
    ///      "description": "Total buy amount in token units",
    ///      "examples": [
    ///        "1457986404.2130240000000000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "buyAmountInUsd": {
    ///      "description": "Total buy amount in USD",
    ///      "examples": [
    ///        "48469.1690094067802589"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "buys": {
    ///      "description": "Number of buy trades",
    ///      "examples": [
    ///        "275"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "currentValue": {
    ///      "description": "Current holding value in USD",
    ///      "examples": [
    ///        "1062513957.429816153652557077014"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "decimals": {
    ///      "description": "Token decimal places",
    ///      "examples": [
    ///        6
    ///      ],
    ///      "type": "integer",
    ///      "format": "int32"
    ///    },
    ///    "firstBuyAt": {
    ///      "description": "Timestamp of first buy (ms since epoch)",
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "isClosed": {
    ///      "description": "Whether the position is fully closed (balance == 0)",
    ///      "type": "boolean"
    ///    },
    ///    "lastSellAt": {
    ///      "description": "Timestamp of last sell (ms since epoch)",
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "logoUri": {
    ///      "description": "Token logo URI",
    ///      "examples": [
    ///        "https://s1.chainstream.io/tokens/images/example.webp"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "losses": {
    ///      "description": "ENTITY.PNL_DETAIL_ITEM.LOSSES",
    ///      "examples": [
    ///        "5"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "name": {
    ///      "description": "Token display name",
    ///      "examples": [
    ///        "The Real World"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "priceInUsd": {
    ///      "description": "Current token price in USD",
    ///      "examples": [
    ///        "0.8466367032033868"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "realizedProfitInUsd": {
    ///      "description": "Realized profit in USD",
    ///      "examples": [
    ///        "67.1297848453256596"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "realizedProfitRatio": {
    ///      "description": "Realized profit ratio",
    ///      "examples": [
    ///        "0.00138499970635554473"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "sellAmount": {
    ///      "description": "Total sell amount in token units",
    ///      "examples": [
    ///        "203004245.5024190000000000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "sellAmountInUsd": {
    ///      "description": "Total sell amount in USD",
    ///      "examples": [
    ///        "6467.3243671310312402"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "sells": {
    ///      "description": "Number of sell trades",
    ///      "examples": [
    ///        "110"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "symbol": {
    ///      "description": "Token ticker symbol",
    ///      "examples": [
    ///        "TRW"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "tokenAddress": {
    ///      "description": "Token contract address",
    ///      "examples": [
    ///        "4MbgMQGvXBWyxKsTfrvkcRgh5FNLg1VxLnzWqbsdPh7p"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "totalCostInUsd": {
    ///      "description": "ENTITY.PNL_DETAIL_ITEM.TOTAL_COST_IN_USD",
    ///      "examples": [
    ///        "48469.17"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "totalProfitInUsd": {
    ///      "description": "Total profit (realized + unrealized) in USD",
    ///      "examples": [
    ///        "1234336400.539050576761666169683200000000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "totalProfitRatio": {
    ///      "description": "Total profit ratio",
    ///      "examples": [
    ///        "25466.423827061972608618047859693225"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "totalTrades": {
    ///      "description": "Total number of trades",
    ///      "examples": [
    ///        "385"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "unrealizedProfitInUsd": {
    ///      "description": "Unrealized profit in USD",
    ///      "examples": [
    ///        "1234336333.409265731436006569683200000000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "unrealizedProfitRatio": {
    ///      "description": "Unrealized profit ratio",
    ///      "examples": [
    ///        "25466.422442062266253073315832775971"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "walletAddress": {
    ///      "description": "Wallet address",
    ///      "examples": [
    ///        "54Pz1e35z9uoFdnxtzjp7xZQoFiofqhdayQWBMN7dsuy"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "wins": {
    ///      "description": "ENTITY.PNL_DETAIL_ITEM.WINS",
    ///      "examples": [
    ///        "12"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct PnlDetailItem {
        ///Average buy price in USD
        #[serde(rename = "avgBuyPriceInUsd")]
        pub avg_buy_price_in_usd: ::std::string::String,
        ///Average profit per trade in USD
        #[serde(rename = "avgProfitPerTradeInUsd")]
        pub avg_profit_per_trade_in_usd: ::std::string::String,
        ///Average sell price in USD
        #[serde(rename = "avgSellPriceInUsd")]
        pub avg_sell_price_in_usd: ::std::string::String,
        ///Current token balance
        pub balance: ::std::string::String,
        ///Total buy amount in token units
        #[serde(rename = "buyAmount")]
        pub buy_amount: ::std::string::String,
        ///Total buy amount in USD
        #[serde(rename = "buyAmountInUsd")]
        pub buy_amount_in_usd: ::std::string::String,
        ///Number of buy trades
        pub buys: ::std::string::String,
        ///Current holding value in USD
        #[serde(rename = "currentValue")]
        pub current_value: ::std::string::String,
        ///Token decimal places
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub decimals: ::std::option::Option<i32>,
        ///Timestamp of first buy (ms since epoch)
        #[serde(
            rename = "firstBuyAt",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub first_buy_at: ::std::option::Option<i64>,
        ///Whether the position is fully closed (balance == 0)
        #[serde(rename = "isClosed")]
        pub is_closed: bool,
        ///Timestamp of last sell (ms since epoch)
        #[serde(
            rename = "lastSellAt",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub last_sell_at: ::std::option::Option<i64>,
        ///Token logo URI
        #[serde(
            rename = "logoUri",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub logo_uri: ::std::option::Option<::std::string::String>,
        ///ENTITY.PNL_DETAIL_ITEM.LOSSES
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub losses: ::std::option::Option<::std::string::String>,
        ///Token display name
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub name: ::std::option::Option<::std::string::String>,
        ///Current token price in USD
        #[serde(rename = "priceInUsd")]
        pub price_in_usd: ::std::string::String,
        ///Realized profit in USD
        #[serde(rename = "realizedProfitInUsd")]
        pub realized_profit_in_usd: ::std::string::String,
        ///Realized profit ratio
        #[serde(rename = "realizedProfitRatio")]
        pub realized_profit_ratio: ::std::string::String,
        ///Total sell amount in token units
        #[serde(rename = "sellAmount")]
        pub sell_amount: ::std::string::String,
        ///Total sell amount in USD
        #[serde(rename = "sellAmountInUsd")]
        pub sell_amount_in_usd: ::std::string::String,
        ///Number of sell trades
        pub sells: ::std::string::String,
        ///Token ticker symbol
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub symbol: ::std::option::Option<::std::string::String>,
        ///Token contract address
        #[serde(rename = "tokenAddress")]
        pub token_address: ::std::string::String,
        ///ENTITY.PNL_DETAIL_ITEM.TOTAL_COST_IN_USD
        #[serde(
            rename = "totalCostInUsd",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub total_cost_in_usd: ::std::option::Option<::std::string::String>,
        ///Total profit (realized + unrealized) in USD
        #[serde(rename = "totalProfitInUsd")]
        pub total_profit_in_usd: ::std::string::String,
        ///Total profit ratio
        #[serde(rename = "totalProfitRatio")]
        pub total_profit_ratio: ::std::string::String,
        ///Total number of trades
        #[serde(rename = "totalTrades")]
        pub total_trades: ::std::string::String,
        ///Unrealized profit in USD
        #[serde(rename = "unrealizedProfitInUsd")]
        pub unrealized_profit_in_usd: ::std::string::String,
        ///Unrealized profit ratio
        #[serde(rename = "unrealizedProfitRatio")]
        pub unrealized_profit_ratio: ::std::string::String,
        ///Wallet address
        #[serde(rename = "walletAddress")]
        pub wallet_address: ::std::string::String,
        ///ENTITY.PNL_DETAIL_ITEM.WINS
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub wins: ::std::option::Option<::std::string::String>,
    }
    impl ::std::convert::From<&PnlDetailItem> for PnlDetailItem {
        fn from(value: &PnlDetailItem) -> Self {
            value.clone()
        }
    }
    impl PnlDetailItem {
        pub fn builder() -> builder::PnlDetailItem {
            Default::default()
        }
    }
    ///Aggregated PnL summary across all items (mirrors TS PnlDetailSummaryDTO).
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Aggregated PnL summary across all items (mirrors TS PnlDetailSummaryDTO).",
    ///  "type": "object",
    ///  "required": [
    ///    "avgProfitPerTradeInUsd",
    ///    "buyAmountInUsd",
    ///    "buys",
    ///    "currentValue",
    ///    "losses",
    ///    "realizedProfitInUsd",
    ///    "realizedProfitRatio",
    ///    "sellAmountInUsd",
    ///    "sells",
    ///    "tokens",
    ///    "totalCostInUsd",
    ///    "totalProfitInUsd",
    ///    "totalTrades",
    ///    "unrealizedProfitInUsd",
    ///    "winRate",
    ///    "wins"
    ///  ],
    ///  "properties": {
    ///    "avgProfitPerTradeInUsd": {
    ///      "description": "Average profit per trade in USD",
    ///      "examples": [
    ///        "3206068.5728287027967835484926836364"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "buyAmountInUsd": {
    ///      "description": "Total buy amount in USD",
    ///      "examples": [
    ///        "48469.1690094067802589"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "buys": {
    ///      "description": "Total buy trades",
    ///      "examples": [
    ///        "275"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "currentValue": {
    ///      "description": "Current total holding value in USD",
    ///      "examples": [
    ///        "1062513957.429816153652557077014"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "losses": {
    ///      "description": "Number of losing trades",
    ///      "examples": [
    ///        "69"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "realizedProfitInUsd": {
    ///      "description": "Total realized profit in USD",
    ///      "examples": [
    ///        "67.1297848453256596"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "realizedProfitRatio": {
    ///      "description": "Total realized profit ratio",
    ///      "examples": [
    ///        "0.0013849997063555447320269173"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "sellAmountInUsd": {
    ///      "description": "Total sell amount in USD",
    ///      "examples": [
    ///        "6467.3243671310312402"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "sells": {
    ///      "description": "Total sell trades",
    ///      "examples": [
    ///        "110"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "tokens": {
    ///      "description": "Total number of traded tokens",
    ///      "examples": [
    ///        "1"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "totalCostInUsd": {
    ///      "description": "Total cost basis in USD",
    ///      "examples": [
    ///        "48469.1690094067802589"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "totalProfitInUsd": {
    ///      "description": "Total profit in USD",
    ///      "examples": [
    ///        "1234336400.5390505767616661696832"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "totalTrades": {
    ///      "description": "Total number of trades",
    ///      "examples": [
    ///        "385"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "unrealizedProfitInUsd": {
    ///      "description": "Total unrealized profit in USD",
    ///      "examples": [
    ///        "1234336333.4092657314360065696832"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "winRate": {
    ///      "description": "Win rate ratio",
    ///      "examples": [
    ///        "0.5688"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "wins": {
    ///      "description": "Number of profitable trades",
    ///      "examples": [
    ///        "91"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct PnlDetailSummary {
        ///Average profit per trade in USD
        #[serde(rename = "avgProfitPerTradeInUsd")]
        pub avg_profit_per_trade_in_usd: ::std::string::String,
        ///Total buy amount in USD
        #[serde(rename = "buyAmountInUsd")]
        pub buy_amount_in_usd: ::std::string::String,
        ///Total buy trades
        pub buys: ::std::string::String,
        ///Current total holding value in USD
        #[serde(rename = "currentValue")]
        pub current_value: ::std::string::String,
        ///Number of losing trades
        pub losses: ::std::string::String,
        ///Total realized profit in USD
        #[serde(rename = "realizedProfitInUsd")]
        pub realized_profit_in_usd: ::std::string::String,
        ///Total realized profit ratio
        #[serde(rename = "realizedProfitRatio")]
        pub realized_profit_ratio: ::std::string::String,
        ///Total sell amount in USD
        #[serde(rename = "sellAmountInUsd")]
        pub sell_amount_in_usd: ::std::string::String,
        ///Total sell trades
        pub sells: ::std::string::String,
        ///Total number of traded tokens
        pub tokens: ::std::string::String,
        ///Total cost basis in USD
        #[serde(rename = "totalCostInUsd")]
        pub total_cost_in_usd: ::std::string::String,
        ///Total profit in USD
        #[serde(rename = "totalProfitInUsd")]
        pub total_profit_in_usd: ::std::string::String,
        ///Total number of trades
        #[serde(rename = "totalTrades")]
        pub total_trades: ::std::string::String,
        ///Total unrealized profit in USD
        #[serde(rename = "unrealizedProfitInUsd")]
        pub unrealized_profit_in_usd: ::std::string::String,
        ///Win rate ratio
        #[serde(rename = "winRate")]
        pub win_rate: ::std::string::String,
        ///Number of profitable trades
        pub wins: ::std::string::String,
    }
    impl ::std::convert::From<&PnlDetailSummary> for PnlDetailSummary {
        fn from(value: &PnlDetailSummary) -> Self {
            value.clone()
        }
    }
    impl PnlDetailSummary {
        pub fn builder() -> builder::PnlDetailSummary {
            Default::default()
        }
    }
    ///Full PnL details result with cursor pagination.
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Full PnL details result with cursor pagination.",
    ///  "type": "object",
    ///  "required": [
    ///    "data",
    ///    "summary"
    ///  ],
    ///  "properties": {
    ///    "data": {
    ///      "description": "List of per-token PnL details",
    ///      "type": "array",
    ///      "items": {
    ///        "$ref": "#/components/schemas/PnlDetailItem"
    ///      }
    ///    },
    ///    "endCursor": {
    ///      "description": "Cursor for the end of current page",
    ///      "examples": [
    ///        "eyJpZCI6ImVuZCJ9"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "hasNext": {
    ///      "description": "Whether there is a next page",
    ///      "examples": [
    ///        false
    ///      ],
    ///      "type": "boolean"
    ///    },
    ///    "hasPrev": {
    ///      "description": "Whether there is a previous page",
    ///      "examples": [
    ///        false
    ///      ],
    ///      "type": "boolean"
    ///    },
    ///    "startCursor": {
    ///      "description": "Cursor for the start of current page",
    ///      "examples": [
    ///        "eyJpZCI6InN0YXJ0In0="
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "summary": {
    ///      "$ref": "#/components/schemas/PnlDetailSummary"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct PnlDetailsResult {
        ///List of per-token PnL details
        pub data: ::std::vec::Vec<PnlDetailItem>,
        ///Cursor for the end of current page
        #[serde(
            rename = "endCursor",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub end_cursor: ::std::option::Option<::std::string::String>,
        ///Whether there is a next page
        #[serde(
            rename = "hasNext",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub has_next: ::std::option::Option<bool>,
        ///Whether there is a previous page
        #[serde(
            rename = "hasPrev",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub has_prev: ::std::option::Option<bool>,
        ///Cursor for the start of current page
        #[serde(
            rename = "startCursor",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub start_cursor: ::std::option::Option<::std::string::String>,
        pub summary: PnlDetailSummary,
    }
    impl ::std::convert::From<&PnlDetailsResult> for PnlDetailsResult {
        fn from(value: &PnlDetailsResult) -> Self {
            value.clone()
        }
    }
    impl PnlDetailsResult {
        pub fn builder() -> builder::PnlDetailsResult {
            Default::default()
        }
    }
    ///PnL resolution period
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "PnL resolution period",
    ///  "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()
        }
    }
    ///Pool sort field
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Pool sort field",
    ///  "type": "string",
    ///  "enum": [
    ///    "tvlInSol",
    ///    "tvlInUsd"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum PoolSortField {
        #[serde(rename = "tvlInSol")]
        TvlInSol,
        #[serde(rename = "tvlInUsd")]
        TvlInUsd,
    }
    impl ::std::convert::From<&Self> for PoolSortField {
        fn from(value: &PoolSortField) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for PoolSortField {
        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 PoolSortField {
        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 PoolSortField {
        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 PoolSortField {
        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 PoolSortField {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    ///`PresignResponseModel`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "presignUrl"
    ///  ],
    ///  "properties": {
    ///    "presignUrl": {
    ///      "description": "Presigned upload URL",
    ///      "examples": [
    ///        "https://uploads.pinata.cloud/v3/files/sign/..."
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct PresignResponseModel {
        ///Presigned upload URL
        #[serde(rename = "presignUrl")]
        pub presign_url: ::std::string::String,
    }
    impl ::std::convert::From<&PresignResponseModel> for PresignResponseModel {
        fn from(value: &PresignResponseModel) -> Self {
            value.clone()
        }
    }
    impl PresignResponseModel {
        pub fn builder() -> builder::PresignResponseModel {
            Default::default()
        }
    }
    ///Price type for candle data
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Price type for candle data",
    ///  "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()
        }
    }
    ///`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()
        }
    }
    ///Range filter condition – mirrors TS `FilterCondition` used with min/max.
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Range filter condition – mirrors TS `FilterCondition` used with min/max.",
    ///  "type": "object",
    ///  "required": [
    ///    "field"
    ///  ],
    ///  "properties": {
    ///    "field": {
    ///      "description": "Filter field name",
    ///      "type": "string"
    ///    },
    ///    "max": {
    ///      "description": "Maximum value (inclusive)",
    ///      "type": "string"
    ///    },
    ///    "min": {
    ///      "description": "Minimum value (inclusive)",
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct RangeFilterCondition {
        ///Filter field name
        pub field: ::std::string::String,
        ///Maximum value (inclusive)
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub max: ::std::option::Option<::std::string::String>,
        ///Minimum value (inclusive)
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub min: ::std::option::Option<::std::string::String>,
    }
    impl ::std::convert::From<&RangeFilterCondition> for RangeFilterCondition {
        fn from(value: &RangeFilterCondition) -> Self {
            value.clone()
        }
    }
    impl RangeFilterCondition {
        pub fn builder() -> builder::RangeFilterCondition {
            Default::default()
        }
    }
    ///`RankingDuration`
    ///
    /// <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 RankingDuration {
        #[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 RankingDuration {
        fn from(value: &RankingDuration) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for RankingDuration {
        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 RankingDuration {
        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 RankingDuration {
        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 RankingDuration {
        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 RankingDuration {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    ///`RankingTag`
    ///
    /// <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 RankingTag {
        #[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 RankingTag {
        fn from(value: &RankingTag) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for RankingTag {
        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 RankingTag {
        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 RankingTag {
        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 RankingTag {
        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 RankingTag {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    ///Red packet detail
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Red packet detail",
    ///  "type": "object",
    ///  "required": [
    ///    "creator",
    ///    "id",
    ///    "maxClaims",
    ///    "mint",
    ///    "totalAmount"
    ///  ],
    ///  "properties": {
    ///    "chain": {
    ///      "description": "Blockchain network for the red packet",
    ///      "examples": [
    ///        "sol"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "claimAuthority": {
    ///      "description": "Claim authority address",
    ///      "examples": [
    ///        "Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "claimedAmount": {
    ///      "description": "Amount claimed from the red packet",
    ///      "examples": [
    ///        "500000000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "claimedCount": {
    ///      "description": "Number of claims made",
    ///      "examples": [
    ///        5
    ///      ],
    ///      "type": "integer",
    ///      "format": "int32"
    ///    },
    ///    "createdAt": {
    ///      "description": "Red packet creation timestamp",
    ///      "examples": [
    ///        1717334400000
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "creator": {
    ///      "description": "Creator wallet address",
    ///      "examples": [
    ///        "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "expiration": {
    ///      "description": "Expiration duration in seconds",
    ///      "examples": [
    ///        24
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "expired": {
    ///      "description": "Whether the red packet has been withdrawn",
    ///      "type": "boolean"
    ///    },
    ///    "expiredAt": {
    ///      "description": "Expiration timestamp",
    ///      "examples": [
    ///        1717420800000
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "id": {
    ///      "description": "Red packet identifier",
    ///      "examples": [
    ///        "Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "maxClaims": {
    ///      "description": "Maximum number of claims allowed",
    ///      "examples": [
    ///        10
    ///      ],
    ///      "type": "integer",
    ///      "format": "int32"
    ///    },
    ///    "memo": {
    ///      "description": "Red packet memo message",
    ///      "examples": [
    ///        "Happy Red Packet"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "mint": {
    ///      "description": "Token mint address",
    ///      "examples": [
    ///        "Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "refundedAmount": {
    ///      "description": "Refunded amount",
    ///      "examples": [
    ///        "0"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "shareId": {
    ///      "description": "Share identifier",
    ///      "examples": [
    ///        "abc123"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "totalAmount": {
    ///      "description": "Total amount in the red packet",
    ///      "examples": [
    ///        "1000000000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "txHash": {
    ///      "description": "Transaction hash",
    ///      "examples": [
    ///        "5UfDuX7hXbL3mFfPdq1pymNHM..."
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct RedPacket {
        ///Blockchain network for the red packet
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub chain: ::std::option::Option<::std::string::String>,
        ///Claim authority address
        #[serde(
            rename = "claimAuthority",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub claim_authority: ::std::option::Option<::std::string::String>,
        ///Amount claimed from the red packet
        #[serde(
            rename = "claimedAmount",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub claimed_amount: ::std::option::Option<::std::string::String>,
        ///Number of claims made
        #[serde(
            rename = "claimedCount",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub claimed_count: ::std::option::Option<i32>,
        ///Red packet creation timestamp
        #[serde(
            rename = "createdAt",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub created_at: ::std::option::Option<i64>,
        ///Creator wallet address
        pub creator: ::std::string::String,
        ///Expiration duration in seconds
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub expiration: ::std::option::Option<i64>,
        ///Whether the red packet has been withdrawn
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub expired: ::std::option::Option<bool>,
        ///Expiration timestamp
        #[serde(
            rename = "expiredAt",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub expired_at: ::std::option::Option<i64>,
        ///Red packet identifier
        pub id: ::std::string::String,
        ///Maximum number of claims allowed
        #[serde(rename = "maxClaims")]
        pub max_claims: i32,
        ///Red packet memo message
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub memo: ::std::option::Option<::std::string::String>,
        ///Token mint address
        pub mint: ::std::string::String,
        ///Refunded amount
        #[serde(
            rename = "refundedAmount",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub refunded_amount: ::std::option::Option<::std::string::String>,
        ///Share identifier
        #[serde(
            rename = "shareId",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub share_id: ::std::option::Option<::std::string::String>,
        ///Total amount in the red packet
        #[serde(rename = "totalAmount")]
        pub total_amount: ::std::string::String,
        ///Transaction hash
        #[serde(
            rename = "txHash",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub tx_hash: ::std::option::Option<::std::string::String>,
    }
    impl ::std::convert::From<&RedPacket> for RedPacket {
        fn from(value: &RedPacket) -> Self {
            value.clone()
        }
    }
    impl RedPacket {
        pub fn builder() -> builder::RedPacket {
            Default::default()
        }
    }
    ///Red packet claim record
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Red packet claim record",
    ///  "type": "object",
    ///  "required": [
    ///    "amount",
    ///    "claimer",
    ///    "mint",
    ///    "packetId"
    ///  ],
    ///  "properties": {
    ///    "amount": {
    ///      "description": "Red packet total amount",
    ///      "examples": [
    ///        "100000000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "chain": {
    ///      "description": "Blockchain network for the red packet",
    ///      "examples": [
    ///        "sol"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "claimedAt": {
    ///      "description": "Claim timestamp",
    ///      "examples": [
    ///        1717334400000
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "claimer": {
    ///      "description": "Claimer wallet address",
    ///      "examples": [
    ///        "Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "creator": {
    ///      "description": "Creator wallet address",
    ///      "examples": [
    ///        "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "mint": {
    ///      "description": "Token mint address",
    ///      "examples": [
    ///        "Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "packetId": {
    ///      "description": "Red packet on-chain ID",
    ///      "examples": [
    ///        "Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "txHash": {
    ///      "description": "Transaction hash",
    ///      "examples": [
    ///        "5UfDuX7hXbL3mFfPdq1pymNHM..."
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct RedPacketClaim {
        ///Red packet total amount
        pub amount: ::std::string::String,
        ///Blockchain network for the red packet
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub chain: ::std::option::Option<::std::string::String>,
        ///Claim timestamp
        #[serde(
            rename = "claimedAt",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub claimed_at: ::std::option::Option<i64>,
        ///Claimer wallet address
        pub claimer: ::std::string::String,
        ///Creator wallet address
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub creator: ::std::option::Option<::std::string::String>,
        ///Token mint address
        pub mint: ::std::string::String,
        ///Red packet on-chain ID
        #[serde(rename = "packetId")]
        pub packet_id: ::std::string::String,
        ///Transaction hash
        #[serde(
            rename = "txHash",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub tx_hash: ::std::option::Option<::std::string::String>,
    }
    impl ::std::convert::From<&RedPacketClaim> for RedPacketClaim {
        fn from(value: &RedPacketClaim) -> Self {
            value.clone()
        }
    }
    impl RedPacketClaim {
        pub fn builder() -> builder::RedPacketClaim {
            Default::default()
        }
    }
    ///Paginated red packet claims response
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Paginated red packet claims response",
    ///  "type": "object",
    ///  "required": [
    ///    "hasNextPage",
    ///    "records",
    ///    "total"
    ///  ],
    ///  "properties": {
    ///    "endCursor": {
    ///      "description": "Cursor for the end of current page",
    ///      "type": "string"
    ///    },
    ///    "hasNextPage": {
    ///      "description": "Whether there is a next page",
    ///      "type": "boolean"
    ///    },
    ///    "records": {
    ///      "description": "List of red packet claims",
    ///      "type": "array",
    ///      "items": {
    ///        "$ref": "#/components/schemas/RedPacketClaim"
    ///      }
    ///    },
    ///    "startCursor": {
    ///      "description": "Cursor for the start of current page",
    ///      "type": "string"
    ///    },
    ///    "total": {
    ///      "description": "Total number of claims",
    ///      "type": "integer",
    ///      "format": "int64"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct RedPacketClaimsPage {
        ///Cursor for the end of current page
        #[serde(
            rename = "endCursor",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub end_cursor: ::std::option::Option<::std::string::String>,
        ///Whether there is a next page
        #[serde(rename = "hasNextPage")]
        pub has_next_page: bool,
        ///List of red packet claims
        pub records: ::std::vec::Vec<RedPacketClaim>,
        ///Cursor for the start of current page
        #[serde(
            rename = "startCursor",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub start_cursor: ::std::option::Option<::std::string::String>,
        ///Total number of claims
        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()
        }
    }
    ///Send red packet transaction request
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Send red packet transaction request",
    ///  "type": "object",
    ///  "required": [
    ///    "signedTx"
    ///  ],
    ///  "properties": {
    ///    "signedTx": {
    ///      "description": "Signed transaction data",
    ///      "examples": [
    ///        "AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAEDRg..."
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct RedPacketSendTxRequest {
        ///Signed transaction data
        #[serde(rename = "signedTx")]
        pub signed_tx: ::std::string::String,
    }
    impl ::std::convert::From<&RedPacketSendTxRequest> for RedPacketSendTxRequest {
        fn from(value: &RedPacketSendTxRequest) -> Self {
            value.clone()
        }
    }
    impl RedPacketSendTxRequest {
        pub fn builder() -> builder::RedPacketSendTxRequest {
            Default::default()
        }
    }
    ///Send red packet transaction response
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Send red packet transaction response",
    ///  "type": "object",
    ///  "required": [
    ///    "signature"
    ///  ],
    ///  "properties": {
    ///    "signature": {
    ///      "description": "Transaction signature",
    ///      "examples": [
    ///        "5UfDuX7hXbL3mFfPdq1pymNHM..."
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct RedPacketSendTxResponse {
        ///Transaction 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()
        }
    }
    ///Paginated red packets response
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Paginated red packets response",
    ///  "type": "object",
    ///  "required": [
    ///    "hasNextPage",
    ///    "records",
    ///    "total"
    ///  ],
    ///  "properties": {
    ///    "endCursor": {
    ///      "description": "Cursor for the end of current page",
    ///      "type": "string"
    ///    },
    ///    "hasNextPage": {
    ///      "description": "Whether there is a next page",
    ///      "type": "boolean"
    ///    },
    ///    "records": {
    ///      "description": "List of red packets",
    ///      "type": "array",
    ///      "items": {
    ///        "$ref": "#/components/schemas/RedPacket"
    ///      }
    ///    },
    ///    "startCursor": {
    ///      "description": "Cursor for the start of current page",
    ///      "type": "string"
    ///    },
    ///    "total": {
    ///      "description": "Total number of red packets",
    ///      "type": "integer",
    ///      "format": "int64"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct RedPacketsPage {
        ///Cursor for the end of current page
        #[serde(
            rename = "endCursor",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub end_cursor: ::std::option::Option<::std::string::String>,
        ///Whether there is a next page
        #[serde(rename = "hasNextPage")]
        pub has_next_page: bool,
        ///List of red packets
        pub records: ::std::vec::Vec<RedPacket>,
        ///Cursor for the start of current page
        #[serde(
            rename = "startCursor",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub start_cursor: ::std::option::Option<::std::string::String>,
        ///Total number of red packets
        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()
        }
    }
    ///Candle resolution
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Candle resolution",
    ///  "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()
        }
    }
    ///Search mode: `fast` returns only OpenSearch fields (default), `normal` enriches with full data.
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Search mode: `fast` returns only OpenSearch fields (default), `normal` enriches with full data.",
    ///  "type": "string",
    ///  "enum": [
    ///    "fast",
    ///    "normal"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum SearchMode {
        #[serde(rename = "fast")]
        Fast,
        #[serde(rename = "normal")]
        Normal,
    }
    impl ::std::convert::From<&Self> for SearchMode {
        fn from(value: &SearchMode) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for SearchMode {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::Fast => f.write_str("fast"),
                Self::Normal => f.write_str("normal"),
            }
        }
    }
    impl ::std::str::FromStr for SearchMode {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "fast" => Ok(Self::Fast),
                "normal" => Ok(Self::Normal),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for SearchMode {
        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 SearchMode {
        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 SearchMode {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    ///`SearchSortBy`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "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()
        }
    }
    ///`SendChain`
    ///
    /// <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 SendChain {
        #[serde(rename = "sol")]
        Sol,
        #[serde(rename = "bsc")]
        Bsc,
        #[serde(rename = "eth")]
        Eth,
    }
    impl ::std::convert::From<&Self> for SendChain {
        fn from(value: &SendChain) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for SendChain {
        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 SendChain {
        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 SendChain {
        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 SendChain {
        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 SendChain {
        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": "jito | direct",
    ///      "examples": [
    ///        {
    ///          "isAntiMev": true
    ///        }
    ///      ],
    ///      "type": "object"
    ///    },
    ///    "signedTx": {
    ///      "description": "Base64 encoded signed transaction",
    ///      "examples": [
    ///        "AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAEDRgYGpQEDAQIABQcICQoLDA0ODwAAAAAAAAAAAAAQERITFBUWFxgZGhscHR4fAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA="
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "submitType": {
    ///      "description": "Transaction submission method",
    ///      "examples": [
    ///        "default"
    ///      ],
    ///      "type": "string",
    ///      "enum": [
    ///        "default",
    ///        "priority"
    ///      ]
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct SendTxInput {
        ///jito | direct
        #[serde(default, skip_serializing_if = "::serde_json::Map::is_empty")]
        pub options: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
        ///Base64 encoded signed transaction
        #[serde(rename = "signedTx")]
        pub signed_tx: ::std::string::String,
        ///Transaction submission method
        #[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()
        }
    }
    ///Transaction submission method
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Transaction submission method",
    ///  "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": "Transaction processing time in milliseconds",
    ///      "examples": [
    ///        1500
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "jobId": {
    ///      "description": "job id",
    ///      "examples": [
    ///        "1234567890"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "signature": {
    ///      "description": "Transaction signature/hash",
    ///      "examples": [
    ///        "37XpPt9Ak6JiE1V3sftJDtdUsvR9FVFRqkZmoT3dp4BTD9pgyTWn1XgHH6R7NjuJ4pBMAgj8JvZtxQrf4s6NTC5F"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct SendTxResponse {
        ///Transaction processing time in milliseconds
        #[serde(rename = "elapsedTime")]
        pub elapsed_time: i64,
        ///job id
        #[serde(rename = "jobId")]
        pub job_id: ::std::string::String,
        ///Transaction signature/hash
        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()
        }
    }
    ///`SerializedSecurityInfo`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "available"
    ///  ],
    ///  "properties": {
    ///    "available": {
    ///      "examples": [
    ///        true
    ///      ],
    ///      "type": "boolean"
    ///    },
    ///    "chainSupported": {
    ///      "examples": [
    ///        true
    ///      ],
    ///      "type": "boolean"
    ///    },
    ///    "isOpenSource": {
    ///      "type": "boolean"
    ///    },
    ///    "isProxy": {
    ///      "type": "boolean"
    ///    },
    ///    "isRenounced": {
    ///      "type": "boolean"
    ///    },
    ///    "isSafe": {
    ///      "type": "boolean"
    ///    },
    ///    "lastRefreshedAt": {
    ///      "examples": [
    ///        "2026-05-13T10:00:00"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "launchpadName": {
    ///      "type": "string"
    ///    },
    ///    "ownerAddress": {
    ///      "type": "string"
    ///    },
    ///    "raw": {},
    ///    "sourceType": {
    ///      "type": "string"
    ///    },
    ///    "vulnCount": {
    ///      "type": "integer",
    ///      "format": "int32"
    ///    },
    ///    "vulnCriticalCount": {
    ///      "type": "integer",
    ///      "format": "int32"
    ///    },
    ///    "vulnMitigatedCount": {
    ///      "type": "integer",
    ///      "format": "int32"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct SerializedSecurityInfo {
        pub available: bool,
        #[serde(
            rename = "chainSupported",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub chain_supported: ::std::option::Option<bool>,
        #[serde(
            rename = "isOpenSource",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub is_open_source: ::std::option::Option<bool>,
        #[serde(
            rename = "isProxy",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub is_proxy: ::std::option::Option<bool>,
        #[serde(
            rename = "isRenounced",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub is_renounced: ::std::option::Option<bool>,
        #[serde(
            rename = "isSafe",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub is_safe: ::std::option::Option<bool>,
        #[serde(
            rename = "lastRefreshedAt",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub last_refreshed_at: ::std::option::Option<::std::string::String>,
        #[serde(
            rename = "launchpadName",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub launchpad_name: ::std::option::Option<::std::string::String>,
        #[serde(
            rename = "ownerAddress",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub owner_address: ::std::option::Option<::std::string::String>,
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub raw: ::std::option::Option<::serde_json::Value>,
        #[serde(
            rename = "sourceType",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub source_type: ::std::option::Option<::std::string::String>,
        #[serde(
            rename = "vulnCount",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub vuln_count: ::std::option::Option<i32>,
        #[serde(
            rename = "vulnCriticalCount",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub vuln_critical_count: ::std::option::Option<i32>,
        #[serde(
            rename = "vulnMitigatedCount",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub vuln_mitigated_count: ::std::option::Option<i32>,
    }
    impl ::std::convert::From<&SerializedSecurityInfo> for SerializedSecurityInfo {
        fn from(value: &SerializedSecurityInfo) -> Self {
            value.clone()
        }
    }
    impl SerializedSecurityInfo {
        pub fn builder() -> builder::SerializedSecurityInfo {
            Default::default()
        }
    }
    ///`SimilarQuery`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "properties": {
    ///    "limit": {
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "type": {
    ///      "$ref": "#/components/schemas/SimilarType"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct SimilarQuery {
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub limit: ::std::option::Option<i64>,
        #[serde(
            rename = "type",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub type_: ::std::option::Option<SimilarType>,
    }
    impl ::std::convert::From<&SimilarQuery> for SimilarQuery {
        fn from(value: &SimilarQuery) -> Self {
            value.clone()
        }
    }
    impl ::std::default::Default for SimilarQuery {
        fn default() -> Self {
            Self {
                limit: Default::default(),
                type_: Default::default(),
            }
        }
    }
    impl SimilarQuery {
        pub fn builder() -> builder::SimilarQuery {
            Default::default()
        }
    }
    ///`SimilarType`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "string",
    ///  "enum": [
    ///    "image",
    ///    "name"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum SimilarType {
        #[serde(rename = "image")]
        Image,
        #[serde(rename = "name")]
        Name,
    }
    impl ::std::convert::From<&Self> for SimilarType {
        fn from(value: &SimilarType) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for SimilarType {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::Image => f.write_str("image"),
                Self::Name => f.write_str("name"),
            }
        }
    }
    impl ::std::str::FromStr for SimilarType {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "image" => Ok(Self::Image),
                "name" => Ok(Self::Name),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for SimilarType {
        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 SimilarType {
        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 SimilarType {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    ///Sort direction (case-insensitive: accepts "asc"/"ASC"/"Asc" etc.)
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Sort direction (case-insensitive: accepts \"asc\"/\"ASC\"/\"Asc\" etc.)",
    ///  "type": "string",
    ///  "enum": [
    ///    "asc",
    ///    "desc"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum SortDirection {
        #[serde(rename = "asc")]
        Asc,
        #[serde(rename = "desc")]
        Desc,
    }
    impl ::std::convert::From<&Self> for SortDirection {
        fn from(value: &SortDirection) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for SortDirection {
        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 SortDirection {
        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 SortDirection {
        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 SortDirection {
        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 SortDirection {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    ///`SuccessResponse`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "success"
    ///  ],
    ///  "properties": {
    ///    "success": {
    ///      "description": "Operation success status",
    ///      "examples": [
    ///        true
    ///      ],
    ///      "type": "boolean"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct SuccessResponse {
        ///Operation success status
        pub success: bool,
    }
    impl ::std::convert::From<&SuccessResponse> for SuccessResponse {
        fn from(value: &SuccessResponse) -> Self {
            value.clone()
        }
    }
    impl SuccessResponse {
        pub fn builder() -> builder::SuccessResponse {
            Default::default()
        }
    }
    ///`SwapInput`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "amount",
    ///    "dex",
    ///    "slippage",
    ///    "swapMode",
    ///    "userAddress"
    ///  ],
    ///  "properties": {
    ///    "amount": {
    ///      "description": "Amount to swap. Use \"auto\" for full balance or percentage like \"50%\"",
    ///      "examples": [
    ///        "1000000000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "dex": {
    ///      "description": "DEX identifier for the trade",
    ///      "examples": [
    ///        "jupiter"
    ///      ],
    ///      "type": "string",
    ///      "enum": [
    ///        "jupiter",
    ///        "kyberswap",
    ///        "raydium",
    ///        "pumpfun",
    ///        "moonshot",
    ///        "candy",
    ///        "launchpad"
    ///      ]
    ///    },
    ///    "inputMint": {
    ///      "description": "Input token mint address",
    ///      "type": "string"
    ///    },
    ///    "outputMint": {
    ///      "description": "Output token mint address",
    ///      "type": "string"
    ///    },
    ///    "poolAddress": {
    ///      "description": "DEX pool address",
    ///      "examples": [
    ///        "58oQChx4yWmvKdwLLZzBi4ChoCc2fqCUWBkwMihLYQo2"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "priorityFee": {
    ///      "description": "Priority fee in SOL to increase transaction processing speed",
    ///      "examples": [
    ///        "1000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "slippage": {
    ///      "description": "Slippage tolerance percentage",
    ///      "default": 10,
    ///      "examples": [
    ///        10
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64",
    ///      "maximum": 100.0,
    ///      "minimum": 0.0
    ///    },
    ///    "swapMode": {
    ///      "description": "Swap direction mode",
    ///      "examples": [
    ///        "ExactIn"
    ///      ],
    ///      "type": "string",
    ///      "enum": [
    ///        "ExactIn",
    ///        "ExactOut"
    ///      ]
    ///    },
    ///    "userAddress": {
    ///      "description": "Public key of the wallet initiating the transaction",
    ///      "examples": [
    ///        "oQPnhXAbLbMuKHESaGrbXT17CyvWCpLyERSJA9HCYd7"
    ///      ],
    ///      "type": "string",
    ///      "maxLength": 64,
    ///      "minLength": 8
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct SwapInput {
        ///Amount to swap. Use "auto" for full balance or percentage like "50%"
        pub amount: ::std::string::String,
        ///DEX identifier for the trade
        pub dex: SwapInputDex,
        ///Input token mint address
        #[serde(
            rename = "inputMint",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub input_mint: ::std::option::Option<::std::string::String>,
        ///Output token mint address
        #[serde(
            rename = "outputMint",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub output_mint: ::std::option::Option<::std::string::String>,
        ///DEX pool address
        #[serde(
            rename = "poolAddress",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub pool_address: ::std::option::Option<::std::string::String>,
        ///Priority fee in SOL to increase transaction processing speed
        #[serde(
            rename = "priorityFee",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub priority_fee: ::std::option::Option<::std::string::String>,
        ///Slippage tolerance percentage
        pub slippage: i64,
        ///Swap direction mode
        #[serde(rename = "swapMode")]
        pub swap_mode: SwapInputSwapMode,
        ///Public key of the wallet initiating the transaction
        #[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()
        }
    }
    ///DEX identifier for the trade
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "DEX identifier for the trade",
    ///  "examples": [
    ///    "jupiter"
    ///  ],
    ///  "type": "string",
    ///  "enum": [
    ///    "jupiter",
    ///    "kyberswap",
    ///    "raydium",
    ///    "pumpfun",
    ///    "moonshot",
    ///    "candy",
    ///    "launchpad"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum SwapInputDex {
        #[serde(rename = "jupiter")]
        Jupiter,
        #[serde(rename = "kyberswap")]
        Kyberswap,
        #[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::Jupiter => f.write_str("jupiter"),
                Self::Kyberswap => f.write_str("kyberswap"),
                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 {
                "jupiter" => Ok(Self::Jupiter),
                "kyberswap" => Ok(Self::Kyberswap),
                "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()
        }
    }
    ///Swap direction mode
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Swap direction 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()
        }
    }
    ///Public key of the wallet initiating the transaction
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Public key of the wallet initiating the transaction",
    ///  "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": "Time taken to process the request in milliseconds",
    ///      "examples": [
    ///        245
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "serializedTx": {
    ///      "description": "Base64 encoded transaction",
    ///      "examples": [
    ///        "AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAEDRgYGpQEDAQIABQcICQoLDA0ODwAAAAAAAAAAAAAQERITFBUWFxgZGhscHR4fAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA="
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct SwapReply {
        ///Time taken to process the request in milliseconds
        #[serde(rename = "elapsedTime")]
        pub elapsed_time: i64,
        ///Base64 encoded transaction
        #[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": "Amount to swap. Use \"auto\" for full balance or percentage like \"50%\"",
    ///      "examples": [
    ///        "1000000000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "deadline": {
    ///      "description": "Swap deadline timestamp",
    ///      "examples": [
    ///        1716806400000
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "dex": {
    ///      "description": "DEX identifier for the trade",
    ///      "examples": [
    ///        "jupiter"
    ///      ],
    ///      "type": "string",
    ///      "enum": [
    ///        "jupiter",
    ///        "kyberswap",
    ///        "raydium",
    ///        "pumpfun",
    ///        "moonshot",
    ///        "candy",
    ///        "launchpad"
    ///      ]
    ///    },
    ///    "gasLimit": {
    ///      "description": "Gas limit for the transaction",
    ///      "examples": [
    ///        "300000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "gasPrice": {
    ///      "description": "Gas price in wei (legacy transactions)",
    ///      "examples": [
    ///        "50000000000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "inputMint": {
    ///      "description": "Input token mint address",
    ///      "examples": [
    ///        "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "isAntiMev": {
    ///      "description": "Whether to enable anti-MEV protection",
    ///      "default": false,
    ///      "examples": [
    ///        true
    ///      ],
    ///      "type": "boolean"
    ///    },
    ///    "maxFeePerGas": {
    ///      "description": "Maximum fee per gas unit (EIP-1559) in wei",
    ///      "examples": [
    ///        "50000000000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "maxPriorityFeePerGas": {
    ///      "description": "Maximum priority fee per gas unit (EIP-1559) in wei",
    ///      "examples": [
    ///        "2000000000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "outputMint": {
    ///      "description": "Output token mint address",
    ///      "examples": [
    ///        "Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "permit": {
    ///      "description": "Permit data for the swap",
    ///      "examples": [
    ///        "66c85d1637257e890e581f724f69f4d4fc17eee156c0619c4719ed0c66eed0e9"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "priorityFee": {
    ///      "description": "Priority fee in SOL to increase transaction processing speed",
    ///      "examples": [
    ///        "1000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "recipientAddress": {
    ///      "description": "Recipient wallet address for the swap",
    ///      "examples": [
    ///        "0x0000000000000000000000000000000000000001"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "slippage": {
    ///      "description": "Slippage tolerance percentage",
    ///      "default": 5,
    ///      "examples": [
    ///        5
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64",
    ///      "maximum": 100.0,
    ///      "minimum": 0.0
    ///    },
    ///    "swapMode": {
    ///      "description": "Swap direction mode",
    ///      "examples": [
    ///        "ExactIn"
    ///      ],
    ///      "type": "string",
    ///      "enum": [
    ///        "ExactIn",
    ///        "ExactOut"
    ///      ]
    ///    },
    ///    "tipFee": {
    ///      "description": "Tip fee in SOL to increase transaction processing speed",
    ///      "examples": [
    ///        "1000000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "userAddress": {
    ///      "description": "Public key of the wallet initiating the transaction",
    ///      "examples": [
    ///        "oQPnhXAbLbMuKHESaGrbXT17CyvWCpLyERSJA9HCYd7"
    ///      ],
    ///      "type": "string",
    ///      "maxLength": 64,
    ///      "minLength": 8
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct SwapRouteInput {
        ///Amount to swap. Use "auto" for full balance or percentage like "50%"
        pub amount: ::std::string::String,
        ///Swap deadline timestamp
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub deadline: ::std::option::Option<i64>,
        ///DEX identifier for the trade
        pub dex: SwapRouteInputDex,
        ///Gas limit for the transaction
        #[serde(
            rename = "gasLimit",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub gas_limit: ::std::option::Option<::std::string::String>,
        ///Gas price in wei (legacy transactions)
        #[serde(
            rename = "gasPrice",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub gas_price: ::std::option::Option<::std::string::String>,
        ///Input token mint address
        #[serde(
            rename = "inputMint",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub input_mint: ::std::option::Option<::std::string::String>,
        ///Whether to enable anti-MEV protection
        #[serde(rename = "isAntiMev", default)]
        pub is_anti_mev: bool,
        ///Maximum fee per gas unit (EIP-1559) in wei
        #[serde(
            rename = "maxFeePerGas",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub max_fee_per_gas: ::std::option::Option<::std::string::String>,
        ///Maximum priority fee per gas unit (EIP-1559) in wei
        #[serde(
            rename = "maxPriorityFeePerGas",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub max_priority_fee_per_gas: ::std::option::Option<::std::string::String>,
        ///Output token mint address
        #[serde(
            rename = "outputMint",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub output_mint: ::std::option::Option<::std::string::String>,
        ///Permit data for the swap
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub permit: ::std::option::Option<::std::string::String>,
        ///Priority fee in SOL to increase transaction processing speed
        #[serde(
            rename = "priorityFee",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub priority_fee: ::std::option::Option<::std::string::String>,
        ///Recipient wallet address for the swap
        #[serde(
            rename = "recipientAddress",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub recipient_address: ::std::option::Option<::std::string::String>,
        ///Slippage tolerance percentage
        pub slippage: i64,
        ///Swap direction mode
        #[serde(rename = "swapMode")]
        pub swap_mode: SwapRouteInputSwapMode,
        ///Tip fee in SOL to increase transaction processing speed
        #[serde(
            rename = "tipFee",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub tip_fee: ::std::option::Option<::std::string::String>,
        ///Public key of the wallet initiating the transaction
        #[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()
        }
    }
    ///DEX identifier for the trade
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "DEX identifier for the trade",
    ///  "examples": [
    ///    "jupiter"
    ///  ],
    ///  "type": "string",
    ///  "enum": [
    ///    "jupiter",
    ///    "kyberswap",
    ///    "raydium",
    ///    "pumpfun",
    ///    "moonshot",
    ///    "candy",
    ///    "launchpad"
    ///  ]
    ///}
    /// ```
    /// </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,
        #[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 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"),
                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 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),
                "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 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()
        }
    }
    ///Swap direction mode
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Swap direction 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()
        }
    }
    ///Public key of the wallet initiating the transaction
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Public key of the wallet initiating the transaction",
    ///  "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": "Original swap request parameters",
    ///      "allOf": [
    ///        {
    ///          "$ref": "#/components/schemas/SwapRouteInput"
    ///        }
    ///      ]
    ///    },
    ///    "elapsedTime": {
    ///      "description": "Time taken to process the request in milliseconds",
    ///      "examples": [
    ///        245
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "lastValidBlockHeight": {
    ///      "description": "Last valid block height for the swap transaction",
    ///      "examples": [
    ///        416681972
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "recentBlockhash": {
    ///      "description": "Recent blockhash for the swap transaction",
    ///      "examples": [
    ///        "JE38e5sYDcpjcfuKA7Madpq8p3A4zc8UQuonCZDbn2yP"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "routeInfo": {
    ///      "description": "Detailed routing information",
    ///      "examples": [
    ///        {
    ///          "inAmount": "1000000000",
    ///          "outAmount": "985000000",
    ///          "priceImpact": "0.15",
    ///          "route": [
    ///            "USDC",
    ///            "SOL"
    ///          ]
    ///        }
    ///      ],
    ///      "type": "object"
    ///    },
    ///    "serializedTx": {
    ///      "description": "Base64 encoded transaction",
    ///      "examples": [
    ///        "AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAEDRgYGpQEDAQIABQcICQoLDA0ODwAAAAAAAAAAAAAQERITFBUWFxgZGhscHR4fAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA="
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct SwapRouteResponse {
        ///Original swap request parameters
        pub args: SwapRouteInput,
        ///Time taken to process the request in milliseconds
        #[serde(rename = "elapsedTime")]
        pub elapsed_time: i64,
        ///Last valid block height for the swap transaction
        #[serde(
            rename = "lastValidBlockHeight",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub last_valid_block_height: ::std::option::Option<i64>,
        ///Recent blockhash for the swap transaction
        #[serde(
            rename = "recentBlockhash",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub recent_blockhash: ::std::option::Option<::std::string::String>,
        ///Detailed routing information
        #[serde(rename = "routeInfo")]
        pub route_info: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
        ///Base64 encoded transaction
        #[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()
        }
    }
    ///Time frame for statistics
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Time frame for statistics",
    ///  "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 TimeFrame {
        #[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 TimeFrame {
        fn from(value: &TimeFrame) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for TimeFrame {
        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 TimeFrame {
        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 TimeFrame {
        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 TimeFrame {
        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 TimeFrame {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    /**Token entity — mirrors TS `TokenDTO extends TokenMetadataDTO`.

TS uses class inheritance to flatten metadata into the top level.
Rust uses `#[serde(flatten)]` for the same effect.*/
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Token entity — mirrors TS `TokenDTO extends TokenMetadataDTO`.\n\nTS uses class inheritance to flatten metadata into the top level.\nRust uses `#[serde(flatten)]` for the same effect.",
    ///  "type": "object",
    ///  "required": [
    ///    "address",
    ///    "chain",
    ///    "decimals",
    ///    "name",
    ///    "symbol"
    ///  ],
    ///  "properties": {
    ///    "address": {
    ///      "description": "Token contract address",
    ///      "examples": [
    ///        "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "chain": {
    ///      "description": "Blockchain network identifier",
    ///      "examples": [
    ///        "sol"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "coingeckoCoinId": {
    ///      "description": "CoinGecko coin identifier",
    ///      "examples": [
    ///        "usd-coin"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "decimals": {
    ///      "description": "Number of decimal places",
    ///      "examples": [
    ///        9
    ///      ],
    ///      "type": "integer",
    ///      "format": "int32"
    ///    },
    ///    "description": {
    ///      "description": "Token description",
    ///      "examples": [
    ///        "USDC is a stablecoin pegged to the US dollar"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "devLastTokenCreatedAt": {
    ///      "description": "Timestamp of developer last token creation",
    ///      "examples": [
    ///        "2025-12-03T09:23:34.000Z"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "devTotalTokens": {
    ///      "description": "Total number of tokens created by the developer",
    ///      "examples": [
    ///        "163"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "extension": {
    ///      "$ref": "#/components/schemas/TokenExtra"
    ///    },
    ///    "extra": {
    ///      "$ref": "#/components/schemas/TokenExtra"
    ///    },
    ///    "imageDup": {
    ///      "description": "ENTITY.TOKEN.IMAGE_DUP",
    ///      "examples": [
    ///        false
    ///      ],
    ///      "type": "boolean"
    ///    },
    ///    "imageHash": {
    ///      "description": "ENTITY.TOKEN.IMAGE_HASH",
    ///      "examples": [
    ///        "a1b2c3d4e5f6a7b8"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "imageUrl": {
    ///      "description": "Token logo image URL",
    ///      "examples": [
    ///        "https://raw.githubusercontent.com/solana-labs/token-list/main/assets/mainnet/EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v/logo.png"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "market": {
    ///      "description": "Trading market identifier",
    ///      "examples": [
    ///        "USDC-SOL"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "marketData": {
    ///      "$ref": "#/components/schemas/TokenMarketData"
    ///    },
    ///    "metadataAddress": {
    ///      "description": "On-chain metadata account address",
    ///      "examples": [
    ///        "metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "name": {
    ///      "description": "Token display name",
    ///      "examples": [
    ///        "USD Coin"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "normalizedName": {
    ///      "description": "ENTITY.TOKEN.NORMALIZED_NAME",
    ///      "examples": [
    ///        "pepe"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "socialMedias": {
    ///      "$ref": "#/components/schemas/TokenSocialMedias"
    ///    },
    ///    "stats": {
    ///      "$ref": "#/components/schemas/TokenStats"
    ///    },
    ///    "symbol": {
    ///      "description": "Token ticker symbol",
    ///      "examples": [
    ///        "USDC"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "tokenCreatedAt": {
    ///      "description": "Token creation timestamp (milliseconds)",
    ///      "examples": [
    ///        1710417600000
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "tokenCreatedBlockHeight": {
    ///      "description": "Block height when token was created",
    ///      "examples": [
    ///        "220000000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "tokenCreatedSlot": {
    ///      "description": "Slot number when token was created",
    ///      "examples": [
    ///        "230000000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "tokenCreatedTxSignature": {
    ///      "description": "Transaction signature of token creation",
    ///      "examples": [
    ///        "5dJ1BxPiFT7w7aBdkxNy2jopGZnZoLwRwS8e9GkEXrVz..."
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "tokenCreators": {
    ///      "description": "List of token creators",
    ///      "type": "array",
    ///      "items": {
    ///        "$ref": "#/components/schemas/TokenCreator"
    ///      }
    ///    },
    ///    "uri": {
    ///      "description": "Token metadata URI",
    ///      "examples": [
    ///        "https://arweave.net/abc123"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct Token {
        ///Token contract address
        pub address: ::std::string::String,
        ///Blockchain network identifier
        pub chain: ::std::string::String,
        ///CoinGecko coin identifier
        #[serde(
            rename = "coingeckoCoinId",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub coingecko_coin_id: ::std::option::Option<::std::string::String>,
        ///Number of decimal places
        pub decimals: i32,
        ///Token description
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub description: ::std::option::Option<::std::string::String>,
        ///Timestamp of developer last token creation
        #[serde(
            rename = "devLastTokenCreatedAt",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub dev_last_token_created_at: ::std::option::Option<::std::string::String>,
        ///Total number of tokens created by the developer
        #[serde(
            rename = "devTotalTokens",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub dev_total_tokens: ::std::option::Option<::std::string::String>,
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub extension: ::std::option::Option<TokenExtra>,
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub extra: ::std::option::Option<TokenExtra>,
        ///ENTITY.TOKEN.IMAGE_DUP
        #[serde(
            rename = "imageDup",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub image_dup: ::std::option::Option<bool>,
        ///ENTITY.TOKEN.IMAGE_HASH
        #[serde(
            rename = "imageHash",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub image_hash: ::std::option::Option<::std::string::String>,
        ///Token logo image URL
        #[serde(
            rename = "imageUrl",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub image_url: ::std::option::Option<::std::string::String>,
        ///Trading market identifier
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub market: ::std::option::Option<::std::string::String>,
        #[serde(
            rename = "marketData",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub market_data: ::std::option::Option<TokenMarketData>,
        ///On-chain metadata account address
        #[serde(
            rename = "metadataAddress",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub metadata_address: ::std::option::Option<::std::string::String>,
        ///Token display name
        pub name: ::std::string::String,
        ///ENTITY.TOKEN.NORMALIZED_NAME
        #[serde(
            rename = "normalizedName",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub normalized_name: ::std::option::Option<::std::string::String>,
        #[serde(
            rename = "socialMedias",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub social_medias: ::std::option::Option<TokenSocialMedias>,
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub stats: ::std::option::Option<TokenStats>,
        ///Token ticker symbol
        pub symbol: ::std::string::String,
        ///Token creation timestamp (milliseconds)
        #[serde(
            rename = "tokenCreatedAt",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub token_created_at: ::std::option::Option<i64>,
        ///Block height when token was created
        #[serde(
            rename = "tokenCreatedBlockHeight",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub token_created_block_height: ::std::option::Option<::std::string::String>,
        ///Slot number when token was created
        #[serde(
            rename = "tokenCreatedSlot",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub token_created_slot: ::std::option::Option<::std::string::String>,
        ///Transaction signature of token creation
        #[serde(
            rename = "tokenCreatedTxSignature",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub token_created_tx_signature: ::std::option::Option<::std::string::String>,
        ///List of token creators
        #[serde(
            rename = "tokenCreators",
            default,
            skip_serializing_if = "::std::vec::Vec::is_empty"
        )]
        pub token_creators: ::std::vec::Vec<TokenCreator>,
        ///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()
        }
    }
    ///Token balance
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Token balance",
    ///  "type": "object",
    ///  "required": [
    ///    "amount",
    ///    "tokenAddress"
    ///  ],
    ///  "properties": {
    ///    "amount": {
    ///      "description": "Balance amount",
    ///      "examples": [
    ///        "1000.50"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "amountInUsd": {
    ///      "description": "Balance in USD",
    ///      "examples": [
    ///        "1000.50"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "decimals": {
    ///      "description": "Token decimals",
    ///      "examples": [
    ///        6
    ///      ],
    ///      "type": "integer",
    ///      "format": "int32"
    ///    },
    ///    "imageUrl": {
    ///      "description": "Token image URL",
    ///      "examples": [
    ///        "https://arweave.net/usdc.png"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "tokenAddress": {
    ///      "description": "Token address",
    ///      "examples": [
    ///        "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "tokenName": {
    ///      "description": "Token name",
    ///      "examples": [
    ///        "USD Coin"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "tokenSymbol": {
    ///      "description": "Token symbol",
    ///      "examples": [
    ///        "USDC"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct TokenBalance {
        ///Balance amount
        pub amount: ::std::string::String,
        ///Balance in USD
        #[serde(
            rename = "amountInUsd",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub amount_in_usd: ::std::option::Option<::std::string::String>,
        ///Token decimals
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub decimals: ::std::option::Option<i32>,
        ///Token image URL
        #[serde(
            rename = "imageUrl",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub image_url: ::std::option::Option<::std::string::String>,
        ///Token address
        #[serde(rename = "tokenAddress")]
        pub token_address: ::std::string::String,
        ///Token name
        #[serde(
            rename = "tokenName",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub token_name: ::std::option::Option<::std::string::String>,
        ///Token symbol
        #[serde(
            rename = "tokenSymbol",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub token_symbol: ::std::option::Option<::std::string::String>,
    }
    impl ::std::convert::From<&TokenBalance> for TokenBalance {
        fn from(value: &TokenBalance) -> Self {
            value.clone()
        }
    }
    impl TokenBalance {
        pub fn builder() -> builder::TokenBalance {
            Default::default()
        }
    }
    ///Token candle (OHLCV)
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Token candle (OHLCV)",
    ///  "type": "object",
    ///  "required": [
    ///    "close",
    ///    "high",
    ///    "low",
    ///    "open",
    ///    "timestamp",
    ///    "volume"
    ///  ],
    ///  "properties": {
    ///    "close": {
    ///      "description": "Close price",
    ///      "examples": [
    ///        "51.2"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "high": {
    ///      "description": "High price",
    ///      "examples": [
    ///        "51.8"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "low": {
    ///      "description": "Low price",
    ///      "examples": [
    ///        "50.1"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "open": {
    ///      "description": "Open price",
    ///      "examples": [
    ///        "50.5"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "timestamp": {
    ///      "description": "Timestamp",
    ///      "examples": [
    ///        1709251200000
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "volume": {
    ///      "description": "Volume",
    ///      "examples": [
    ///        "1000000"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct TokenCandle {
        ///Close price
        pub close: ::std::string::String,
        ///High price
        pub high: ::std::string::String,
        ///Low price
        pub low: ::std::string::String,
        ///Open price
        pub open: ::std::string::String,
        ///Timestamp
        pub timestamp: i64,
        ///Volume
        pub volume: ::std::string::String,
    }
    impl ::std::convert::From<&TokenCandle> for TokenCandle {
        fn from(value: &TokenCandle) -> Self {
            value.clone()
        }
    }
    impl TokenCandle {
        pub fn builder() -> builder::TokenCandle {
            Default::default()
        }
    }
    ///Token creation info — mirrors TS `TokenCreationDTO`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Token creation info — mirrors TS `TokenCreationDTO`",
    ///  "type": "object",
    ///  "required": [
    ///    "blockHeight",
    ///    "blockSlot",
    ///    "tokenAddress",
    ///    "transactionSignature",
    ///    "type"
    ///  ],
    ///  "properties": {
    ///    "blockHash": {
    ///      "description": "Block hash of creation transaction",
    ///      "examples": [
    ///        "5J7X9K2M4N6P8Q"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "blockHeight": {
    ///      "description": "Block height of creation transaction",
    ///      "examples": [
    ///        123456789
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "blockSlot": {
    ///      "description": "Block slot of creation transaction",
    ///      "examples": [
    ///        123456789
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "blockTimestamp": {
    ///      "description": "Block timestamp of creation (milliseconds)",
    ///      "examples": [
    ///        1754055151000
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "tokenAddress": {
    ///      "description": "Token contract address",
    ///      "examples": [
    ///        "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "transactionSignature": {
    ///      "description": "Creation transaction signature",
    ///      "examples": [
    ///        "3A7B9C1D2E4F6G8"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "type": {
    ///      "description": "Token creation type",
    ///      "examples": [
    ///        "create"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct TokenCreation {
        ///Block hash of creation transaction
        #[serde(
            rename = "blockHash",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub block_hash: ::std::option::Option<::std::string::String>,
        ///Block height of creation transaction
        #[serde(rename = "blockHeight")]
        pub block_height: i64,
        ///Block slot of creation transaction
        #[serde(rename = "blockSlot")]
        pub block_slot: i64,
        ///Block timestamp of creation (milliseconds)
        #[serde(
            rename = "blockTimestamp",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub block_timestamp: ::std::option::Option<i64>,
        ///Token contract address
        #[serde(rename = "tokenAddress")]
        pub token_address: ::std::string::String,
        ///Creation transaction signature
        #[serde(rename = "transactionSignature")]
        pub transaction_signature: ::std::string::String,
        ///Token creation type
        #[serde(rename = "type")]
        pub type_: ::std::string::String,
    }
    impl ::std::convert::From<&TokenCreation> for TokenCreation {
        fn from(value: &TokenCreation) -> Self {
            value.clone()
        }
    }
    impl TokenCreation {
        pub fn builder() -> builder::TokenCreation {
            Default::default()
        }
    }
    ///Token creator info
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Token creator info",
    ///  "type": "object",
    ///  "properties": {
    ///    "address": {
    ///      "description": "Creator wallet address",
    ///      "examples": [
    ///        "5e2qRc1DNEXmyxP8qwPwJhRWjef7usLyi7v5xjqLr5G7"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "isVerified": {
    ///      "description": "Whether the creator is verified",
    ///      "examples": [
    ///        true
    ///      ],
    ///      "type": "boolean"
    ///    },
    ///    "share": {
    ///      "description": "Creator revenue share percentage",
    ///      "examples": [
    ///        100
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct TokenCreator {
        ///Creator wallet address
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub address: ::std::option::Option<::std::string::String>,
        ///Whether the creator is verified
        #[serde(
            rename = "isVerified",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub is_verified: ::std::option::Option<bool>,
        ///Creator revenue share percentage
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub share: ::std::option::Option<i64>,
    }
    impl ::std::convert::From<&TokenCreator> for TokenCreator {
        fn from(value: &TokenCreator) -> Self {
            value.clone()
        }
    }
    impl ::std::default::Default for TokenCreator {
        fn default() -> Self {
            Self {
                address: Default::default(),
                is_verified: Default::default(),
                share: Default::default(),
            }
        }
    }
    impl TokenCreator {
        pub fn builder() -> builder::TokenCreator {
            Default::default()
        }
    }
    ///Token extra metadata
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Token extra metadata",
    ///  "type": "object",
    ///  "properties": {
    ///    "collectionAddress": {
    ///      "description": "NFT collection address",
    ///      "examples": [
    ///        "ABCDE"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "editionNonce": {
    ///      "description": "Edition nonce value",
    ///      "examples": [
    ///        1
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "freezeAuthority": {
    ///      "description": "Freeze authority address",
    ///      "examples": [
    ///        "B61ZzjjZskE9yur2CBe4H4NFS3XHdEZdatKNegC9smUV"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "fungible": {
    ///      "description": "Whether the token is fungible",
    ///      "examples": [
    ///        true
    ///      ],
    ///      "type": "boolean"
    ///    },
    ///    "isMutable": {
    ///      "description": "Whether metadata is mutable",
    ///      "examples": [
    ///        true
    ///      ],
    ///      "type": "boolean"
    ///    },
    ///    "isNative": {
    ///      "description": "Whether the token is native (e.g., SOL)",
    ///      "examples": [
    ///        false
    ///      ],
    ///      "type": "boolean"
    ///    },
    ///    "isVerifiedCollection": {
    ///      "description": "Whether the collection is verified",
    ///      "examples": [
    ///        true
    ///      ],
    ///      "type": "boolean"
    ///    },
    ///    "isWrapped": {
    ///      "description": "Whether the token is wrapped",
    ///      "examples": [
    ///        false
    ///      ],
    ///      "type": "boolean"
    ///    },
    ///    "key": {
    ///      "description": "Metaplex account key type",
    ///      "examples": [
    ///        "Mint"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "launchFromProgramAddress": {
    ///      "description": "Launch platform program address",
    ///      "examples": [
    ///        "6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "launchFromProtocolFamily": {
    ///      "description": "Launch platform protocol family",
    ///      "examples": [
    ///        "pumpfun"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "migratedAt": {
    ///      "description": "Migration timestamp (milliseconds)",
    ///      "examples": [
    ///        1714857600000
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "migratedToPoolAddress": {
    ///      "description": "Migrated-to pool address",
    ///      "examples": [
    ///        "7AvUMqLBou5EAXzyhnizWmPU13u2VguJoBYdcX4bhJtQ"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "migratedToProgramAddress": {
    ///      "description": "Migrated-to program address",
    ///      "examples": [
    ///        "pAMMBay6oceH9fJKBRHGP5D4bD4sWpmSwMn52FMfXEA"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "migratedToProtocolFamily": {
    ///      "description": "Migrated-to protocol family",
    ///      "examples": [
    ///        "Raydium"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "mintAuthority": {
    ///      "description": "Mint authority address",
    ///      "examples": [
    ///        "B61ZzjjZskE9yur2CBe4H4NFS3XHdEZdatKNegC9smUV"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "primarySaleHappened": {
    ///      "description": "Whether the primary sale has occurred",
    ///      "examples": [
    ///        false
    ///      ],
    ///      "type": "boolean"
    ///    },
    ///    "programAddress": {
    ///      "description": "Token program address",
    ///      "examples": [
    ///        "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "sellerFeeBasisPoints": {
    ///      "description": "Seller fee in basis points",
    ///      "examples": [
    ///        100
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "tokenStandard": {
    ///      "description": "Token standard (e.g., Fungible)",
    ///      "examples": [
    ///        "Fungible"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "updateAuthority": {
    ///      "description": "Update authority address",
    ///      "examples": [
    ///        "B61ZzjjZskE9yur2CBe4H4NFS3XHdEZdatKNegC9smUV"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct TokenExtra {
        ///NFT collection address
        #[serde(
            rename = "collectionAddress",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub collection_address: ::std::option::Option<::std::string::String>,
        ///Edition nonce value
        #[serde(
            rename = "editionNonce",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub edition_nonce: ::std::option::Option<i64>,
        ///Freeze authority address
        #[serde(
            rename = "freezeAuthority",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub freeze_authority: ::std::option::Option<::std::string::String>,
        ///Whether the token is fungible
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub fungible: ::std::option::Option<bool>,
        ///Whether metadata is mutable
        #[serde(
            rename = "isMutable",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub is_mutable: ::std::option::Option<bool>,
        ///Whether the token is native (e.g., SOL)
        #[serde(
            rename = "isNative",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub is_native: ::std::option::Option<bool>,
        ///Whether the collection is verified
        #[serde(
            rename = "isVerifiedCollection",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub is_verified_collection: ::std::option::Option<bool>,
        ///Whether the token is wrapped
        #[serde(
            rename = "isWrapped",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub is_wrapped: ::std::option::Option<bool>,
        ///Metaplex account key type
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub key: ::std::option::Option<::std::string::String>,
        ///Launch platform 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>,
        ///Launch platform 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>,
        ///Migration timestamp (milliseconds)
        #[serde(
            rename = "migratedAt",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub migrated_at: ::std::option::Option<i64>,
        ///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>,
        ///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>,
        ///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>,
        ///Mint authority address
        #[serde(
            rename = "mintAuthority",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub mint_authority: ::std::option::Option<::std::string::String>,
        ///Whether the primary sale has occurred
        #[serde(
            rename = "primarySaleHappened",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub primary_sale_happened: ::std::option::Option<bool>,
        ///Token program address
        #[serde(
            rename = "programAddress",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub program_address: ::std::option::Option<::std::string::String>,
        ///Seller fee in basis points
        #[serde(
            rename = "sellerFeeBasisPoints",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub seller_fee_basis_points: ::std::option::Option<i64>,
        ///Token standard (e.g., Fungible)
        #[serde(
            rename = "tokenStandard",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub token_standard: ::std::option::Option<::std::string::String>,
        ///Update authority address
        #[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<&TokenExtra> for TokenExtra {
        fn from(value: &TokenExtra) -> Self {
            value.clone()
        }
    }
    impl ::std::default::Default for TokenExtra {
        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 TokenExtra {
        pub fn builder() -> builder::TokenExtra {
            Default::default()
        }
    }
    ///`TokenField`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "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",
    ///    "marketData.athMarketCapInUsd"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum TokenField {
        #[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,
        #[serde(rename = "marketData.athMarketCapInUsd")]
        MarketDataAthMarketCapInUsd,
    }
    impl ::std::convert::From<&Self> for TokenField {
        fn from(value: &TokenField) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for TokenField {
        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"),
                Self::MarketDataAthMarketCapInUsd => {
                    f.write_str("marketData.athMarketCapInUsd")
                }
            }
        }
    }
    impl ::std::str::FromStr for TokenField {
        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),
                "marketData.athMarketCapInUsd" => Ok(Self::MarketDataAthMarketCapInUsd),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for TokenField {
        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 TokenField {
        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 TokenField {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    ///`TokenFilter`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "string",
    ///  "enum": [
    ///    "has_social_media",
    ///    "has_twitter",
    ///    "has_telegram",
    ///    "has_website",
    ///    "has_tiktok",
    ///    "has_discord",
    ///    "has_facebook",
    ///    "has_github",
    ///    "has_instagram",
    ///    "has_linkedin",
    ///    "has_medium",
    ///    "has_reddit",
    ///    "has_youtube",
    ///    "has_bitbucket"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum TokenFilter {
        #[serde(rename = "has_social_media")]
        HasSocialMedia,
        #[serde(rename = "has_twitter")]
        HasTwitter,
        #[serde(rename = "has_telegram")]
        HasTelegram,
        #[serde(rename = "has_website")]
        HasWebsite,
        #[serde(rename = "has_tiktok")]
        HasTiktok,
        #[serde(rename = "has_discord")]
        HasDiscord,
        #[serde(rename = "has_facebook")]
        HasFacebook,
        #[serde(rename = "has_github")]
        HasGithub,
        #[serde(rename = "has_instagram")]
        HasInstagram,
        #[serde(rename = "has_linkedin")]
        HasLinkedin,
        #[serde(rename = "has_medium")]
        HasMedium,
        #[serde(rename = "has_reddit")]
        HasReddit,
        #[serde(rename = "has_youtube")]
        HasYoutube,
        #[serde(rename = "has_bitbucket")]
        HasBitbucket,
    }
    impl ::std::convert::From<&Self> for TokenFilter {
        fn from(value: &TokenFilter) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for TokenFilter {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::HasSocialMedia => f.write_str("has_social_media"),
                Self::HasTwitter => f.write_str("has_twitter"),
                Self::HasTelegram => f.write_str("has_telegram"),
                Self::HasWebsite => f.write_str("has_website"),
                Self::HasTiktok => f.write_str("has_tiktok"),
                Self::HasDiscord => f.write_str("has_discord"),
                Self::HasFacebook => f.write_str("has_facebook"),
                Self::HasGithub => f.write_str("has_github"),
                Self::HasInstagram => f.write_str("has_instagram"),
                Self::HasLinkedin => f.write_str("has_linkedin"),
                Self::HasMedium => f.write_str("has_medium"),
                Self::HasReddit => f.write_str("has_reddit"),
                Self::HasYoutube => f.write_str("has_youtube"),
                Self::HasBitbucket => f.write_str("has_bitbucket"),
            }
        }
    }
    impl ::std::str::FromStr for TokenFilter {
        type Err = self::error::ConversionError;
        fn from_str(
            value: &str,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "has_social_media" => Ok(Self::HasSocialMedia),
                "has_twitter" => Ok(Self::HasTwitter),
                "has_telegram" => Ok(Self::HasTelegram),
                "has_website" => Ok(Self::HasWebsite),
                "has_tiktok" => Ok(Self::HasTiktok),
                "has_discord" => Ok(Self::HasDiscord),
                "has_facebook" => Ok(Self::HasFacebook),
                "has_github" => Ok(Self::HasGithub),
                "has_instagram" => Ok(Self::HasInstagram),
                "has_linkedin" => Ok(Self::HasLinkedin),
                "has_medium" => Ok(Self::HasMedium),
                "has_reddit" => Ok(Self::HasReddit),
                "has_youtube" => Ok(Self::HasYoutube),
                "has_bitbucket" => Ok(Self::HasBitbucket),
                _ => Err("invalid value".into()),
            }
        }
    }
    impl ::std::convert::TryFrom<&str> for TokenFilter {
        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 TokenFilter {
        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 TokenFilter {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    ///Token holder
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Token holder",
    ///  "type": "object",
    ///  "required": [
    ///    "amount",
    ///    "amountInUsd",
    ///    "percentage",
    ///    "walletAddress"
    ///  ],
    ///  "properties": {
    ///    "accuCost": {
    ///      "description": "Traceable position accumulated cost, USD (GMGN: accu_cost)",
    ///      "type": "string"
    ///    },
    ///    "amount": {
    ///      "description": "Token holding amount",
    ///      "examples": [
    ///        "1000000000000000000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "amountInUsd": {
    ///      "description": "Token holding value in USD",
    ///      "examples": [
    ///        "1000000000000000000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "avgBuyPriceUsd": {
    ///      "description": "Average buy price in USD per token (all-time)",
    ///      "type": "string"
    ///    },
    ///    "avgCostUsd": {
    ///      "description": "Average cost per token in USD (current position cost basis)",
    ///      "type": "string"
    ///    },
    ///    "avgSellPriceUsd": {
    ///      "description": "Average sell price in USD per token (all-time)",
    ///      "type": "string"
    ///    },
    ///    "buyAmountCur": {
    ///      "description": "Cumulative token quantity bought, all-time (GMGN: buy_amount_cur / history_bought_amount)",
    ///      "type": "string"
    ///    },
    ///    "buyVolumeNative": {
    ///      "description": "All-time total buy volume in native token",
    ///      "type": "string"
    ///    },
    ///    "buyVolumeUsd": {
    ///      "description": "All-time total buy volume in USD",
    ///      "type": "string"
    ///    },
    ///    "endHoldingAt": {
    ///      "description": "Timestamp when holder fully closed position (ms since epoch)",
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "firstBuyTime": {
    ///      "description": "Timestamp of first token purchase (ms since epoch)",
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "historyBoughtCost": {
    ///      "description": "Total DEX buy cost including fees, USD (GMGN: history_bought_cost)",
    ///      "type": "string"
    ///    },
    ///    "historyBoughtFee": {
    ///      "description": "Total DEX buy fees, USD (GMGN: history_bought_fee)",
    ///      "type": "string"
    ///    },
    ///    "historySoldFee": {
    ///      "description": "Total DEX sell fees, USD (GMGN: history_sold_fee)",
    ///      "type": "string"
    ///    },
    ///    "historySoldIncome": {
    ///      "description": "Total DEX sell income, USD (GMGN: history_sold_income)",
    ///      "type": "string"
    ///    },
    ///    "historyTransferInAmount": {
    ///      "description": "Cumulative transfer-in token qty (GMGN: history_transfer_in_amount)",
    ///      "type": "string"
    ///    },
    ///    "historyTransferInCost": {
    ///      "description": "Transfer-in USD cost basis (GMGN: history_transfer_in_cost)",
    ///      "type": "string"
    ///    },
    ///    "historyTransferOutAmount": {
    ///      "description": "Cumulative transfer-out token qty (GMGN: history_transfer_out_amount)",
    ///      "type": "string"
    ///    },
    ///    "historyTransferOutIncome": {
    ///      "description": "Transfer-out USD income (GMGN: history_transfer_out_income)",
    ///      "type": "string"
    ///    },
    ///    "isClosed": {
    ///      "description": "Whether the token position is fully closed (balance = 0)",
    ///      "type": "boolean"
    ///    },
    ///    "isTransferIn": {
    ///      "description": "Position acquired purely via transfers, no DEX buy (GMGN: transfer_in)",
    ///      "type": "boolean"
    ///    },
    ///    "lastActiveAt": {
    ///      "description": "Last active timestamp (ms since epoch)",
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "lossCount": {
    ///      "description": "Number of losing trades (PnL < 0)",
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "makerTokenTags": {
    ///      "description": "Per-token position/behaviour tags derived at query time.\nPossible values: \"top_holder\" (rank ≤ 10, first page only),\n\"whale\" (holding > $10,000 USD), \"diamond_hands\" (held > 30 days).",
    ///      "type": "array",
    ///      "items": {
    ///        "type": "string"
    ///      }
    ///    },
    ///    "nativeBalance": {
    ///      "description": "Native chain token balance in lamports (SOL) or wei (EVM), as decimal string.\nFetched from RPC with a 10-second Redis cache.",
    ///      "type": "string"
    ///    },
    ///    "netflowUsd": {
    ///      "description": "Net USD inflow (buy_volume_usd − sell_volume_usd); positive = net buyer",
    ///      "type": "string"
    ///    },
    ///    "percentage": {
    ///      "description": "Percentage of total supply held",
    ///      "examples": [
    ///        "100"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "positionCostUsd": {
    ///      "description": "Current open position cost in USD",
    ///      "type": "string"
    ///    },
    ///    "realizedPnlRatio": {
    ///      "description": "Realized PnL / total_cost ratio (GMGN: realized_pnl)",
    ///      "type": "string"
    ///    },
    ///    "realizedProfit": {
    ///      "description": "Realized PnL in USD (all-time)",
    ///      "type": "string"
    ///    },
    ///    "roi": {
    ///      "description": "Return on investment = total_pnl / total_cost_all (e.g. 0.25 = 25%)",
    ///      "type": "string"
    ///    },
    ///    "sellAmountCur": {
    ///      "description": "Cumulative token quantity sold, all-time (GMGN: sell_amount_cur / history_sold_amount)",
    ///      "type": "string"
    ///    },
    ///    "sellAmountPercentage": {
    ///      "description": "Sell quantity / buy quantity, capped 0–1 (GMGN: sell_amount_percentage)",
    ///      "type": "string"
    ///    },
    ///    "sellVolumeNative": {
    ///      "description": "All-time total sell volume in native token",
    ///      "type": "string"
    ///    },
    ///    "sellVolumeUsd": {
    ///      "description": "All-time total sell volume in USD",
    ///      "type": "string"
    ///    },
    ///    "startHoldingAt": {
    ///      "description": "Timestamp when holder first acquired the token (ms since epoch)",
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "tags": {
    ///      "description": "Trader classification tags (e.g. \"kol\", \"smart\", \"sniper\")",
    ///      "type": "array",
    ///      "items": {
    ///        "type": "string"
    ///      }
    ///    },
    ///    "totalBuyCount": {
    ///      "description": "All-time total buy trade count",
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "totalCostUsd": {
    ///      "description": "All-time accumulated cost basis in USD (total_cost_all from pnl-sync)",
    ///      "type": "string"
    ///    },
    ///    "totalProfit": {
    ///      "description": "Total PnL in USD (realized + unrealized)",
    ///      "type": "string"
    ///    },
    ///    "totalSellCount": {
    ///      "description": "All-time total sell trade count",
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "transferInAmount7d": {
    ///      "description": "Inbound transfer volume in native token over last 7 days",
    ///      "type": "string"
    ///    },
    ///    "transferInCount": {
    ///      "description": "Number of token transfer-in events (GMGN: transfer_in_count)",
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "transferOutAmount7d": {
    ///      "description": "Outbound transfer volume in native token over last 7 days",
    ///      "type": "string"
    ///    },
    ///    "transferOutCount": {
    ///      "description": "Number of token transfer-out events (GMGN: transfer_out_count)",
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "unrealizedProfit": {
    ///      "description": "Unrealized PnL in USD (current position)",
    ///      "type": "string"
    ///    },
    ///    "walletAddress": {
    ///      "description": "Holder wallet address",
    ///      "examples": [
    ///        "0x1234567890abcdef"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "walletTagV2": {
    ///      "description": "Global rank tag on this token when sorted by balance (e.g. \"TOP1\", \"TOP2\").\nOnly present on the first page of a balance-sorted query (no cursor).",
    ///      "type": "string"
    ///    },
    ///    "winCount": {
    ///      "description": "Number of winning trades (PnL > 0)",
    ///      "type": "integer",
    ///      "format": "int64"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct TokenHolder {
        ///Traceable position accumulated cost, USD (GMGN: accu_cost)
        #[serde(
            rename = "accuCost",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub accu_cost: ::std::option::Option<::std::string::String>,
        ///Token holding amount
        pub amount: ::std::string::String,
        ///Token holding value in USD
        #[serde(rename = "amountInUsd")]
        pub amount_in_usd: ::std::string::String,
        ///Average buy price in USD per token (all-time)
        #[serde(
            rename = "avgBuyPriceUsd",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub avg_buy_price_usd: ::std::option::Option<::std::string::String>,
        ///Average cost per token in USD (current position cost basis)
        #[serde(
            rename = "avgCostUsd",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub avg_cost_usd: ::std::option::Option<::std::string::String>,
        ///Average sell price in USD per token (all-time)
        #[serde(
            rename = "avgSellPriceUsd",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub avg_sell_price_usd: ::std::option::Option<::std::string::String>,
        ///Cumulative token quantity bought, all-time (GMGN: buy_amount_cur / history_bought_amount)
        #[serde(
            rename = "buyAmountCur",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub buy_amount_cur: ::std::option::Option<::std::string::String>,
        ///All-time total buy volume in native token
        #[serde(
            rename = "buyVolumeNative",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub buy_volume_native: ::std::option::Option<::std::string::String>,
        ///All-time total buy volume in USD
        #[serde(
            rename = "buyVolumeUsd",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub buy_volume_usd: ::std::option::Option<::std::string::String>,
        ///Timestamp when holder fully closed position (ms since epoch)
        #[serde(
            rename = "endHoldingAt",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub end_holding_at: ::std::option::Option<i64>,
        ///Timestamp of first token purchase (ms since epoch)
        #[serde(
            rename = "firstBuyTime",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub first_buy_time: ::std::option::Option<i64>,
        ///Total DEX buy cost including fees, USD (GMGN: history_bought_cost)
        #[serde(
            rename = "historyBoughtCost",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub history_bought_cost: ::std::option::Option<::std::string::String>,
        ///Total DEX buy fees, USD (GMGN: history_bought_fee)
        #[serde(
            rename = "historyBoughtFee",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub history_bought_fee: ::std::option::Option<::std::string::String>,
        ///Total DEX sell fees, USD (GMGN: history_sold_fee)
        #[serde(
            rename = "historySoldFee",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub history_sold_fee: ::std::option::Option<::std::string::String>,
        ///Total DEX sell income, USD (GMGN: history_sold_income)
        #[serde(
            rename = "historySoldIncome",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub history_sold_income: ::std::option::Option<::std::string::String>,
        ///Cumulative transfer-in token qty (GMGN: history_transfer_in_amount)
        #[serde(
            rename = "historyTransferInAmount",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub history_transfer_in_amount: ::std::option::Option<::std::string::String>,
        ///Transfer-in USD cost basis (GMGN: history_transfer_in_cost)
        #[serde(
            rename = "historyTransferInCost",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub history_transfer_in_cost: ::std::option::Option<::std::string::String>,
        ///Cumulative transfer-out token qty (GMGN: history_transfer_out_amount)
        #[serde(
            rename = "historyTransferOutAmount",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub history_transfer_out_amount: ::std::option::Option<::std::string::String>,
        ///Transfer-out USD income (GMGN: history_transfer_out_income)
        #[serde(
            rename = "historyTransferOutIncome",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub history_transfer_out_income: ::std::option::Option<::std::string::String>,
        ///Whether the token position is fully closed (balance = 0)
        #[serde(
            rename = "isClosed",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub is_closed: ::std::option::Option<bool>,
        ///Position acquired purely via transfers, no DEX buy (GMGN: transfer_in)
        #[serde(
            rename = "isTransferIn",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub is_transfer_in: ::std::option::Option<bool>,
        ///Last active timestamp (ms since epoch)
        #[serde(
            rename = "lastActiveAt",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub last_active_at: ::std::option::Option<i64>,
        ///Number of losing trades (PnL < 0)
        #[serde(
            rename = "lossCount",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub loss_count: ::std::option::Option<i64>,
        /**Per-token position/behaviour tags derived at query time.
Possible values: "top_holder" (rank ≤ 10, first page only),
"whale" (holding > $10,000 USD), "diamond_hands" (held > 30 days).*/
        #[serde(
            rename = "makerTokenTags",
            default,
            skip_serializing_if = "::std::vec::Vec::is_empty"
        )]
        pub maker_token_tags: ::std::vec::Vec<::std::string::String>,
        /**Native chain token balance in lamports (SOL) or wei (EVM), as decimal string.
Fetched from RPC with a 10-second Redis cache.*/
        #[serde(
            rename = "nativeBalance",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub native_balance: ::std::option::Option<::std::string::String>,
        ///Net USD inflow (buy_volume_usd − sell_volume_usd); positive = net buyer
        #[serde(
            rename = "netflowUsd",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub netflow_usd: ::std::option::Option<::std::string::String>,
        ///Percentage of total supply held
        pub percentage: ::std::string::String,
        ///Current open position cost in USD
        #[serde(
            rename = "positionCostUsd",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub position_cost_usd: ::std::option::Option<::std::string::String>,
        ///Realized PnL / total_cost ratio (GMGN: realized_pnl)
        #[serde(
            rename = "realizedPnlRatio",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub realized_pnl_ratio: ::std::option::Option<::std::string::String>,
        ///Realized PnL in USD (all-time)
        #[serde(
            rename = "realizedProfit",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub realized_profit: ::std::option::Option<::std::string::String>,
        ///Return on investment = total_pnl / total_cost_all (e.g. 0.25 = 25%)
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub roi: ::std::option::Option<::std::string::String>,
        ///Cumulative token quantity sold, all-time (GMGN: sell_amount_cur / history_sold_amount)
        #[serde(
            rename = "sellAmountCur",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub sell_amount_cur: ::std::option::Option<::std::string::String>,
        ///Sell quantity / buy quantity, capped 0–1 (GMGN: sell_amount_percentage)
        #[serde(
            rename = "sellAmountPercentage",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub sell_amount_percentage: ::std::option::Option<::std::string::String>,
        ///All-time total sell volume in native token
        #[serde(
            rename = "sellVolumeNative",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub sell_volume_native: ::std::option::Option<::std::string::String>,
        ///All-time total sell volume in USD
        #[serde(
            rename = "sellVolumeUsd",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub sell_volume_usd: ::std::option::Option<::std::string::String>,
        ///Timestamp when holder first acquired the token (ms since epoch)
        #[serde(
            rename = "startHoldingAt",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub start_holding_at: ::std::option::Option<i64>,
        ///Trader classification tags (e.g. "kol", "smart", "sniper")
        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
        pub tags: ::std::vec::Vec<::std::string::String>,
        ///All-time total buy trade count
        #[serde(
            rename = "totalBuyCount",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub total_buy_count: ::std::option::Option<i64>,
        ///All-time accumulated cost basis in USD (total_cost_all from pnl-sync)
        #[serde(
            rename = "totalCostUsd",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub total_cost_usd: ::std::option::Option<::std::string::String>,
        ///Total PnL in USD (realized + unrealized)
        #[serde(
            rename = "totalProfit",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub total_profit: ::std::option::Option<::std::string::String>,
        ///All-time total sell trade count
        #[serde(
            rename = "totalSellCount",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub total_sell_count: ::std::option::Option<i64>,
        ///Inbound transfer volume in native token over last 7 days
        #[serde(
            rename = "transferInAmount7d",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub transfer_in_amount7d: ::std::option::Option<::std::string::String>,
        ///Number of token transfer-in events (GMGN: transfer_in_count)
        #[serde(
            rename = "transferInCount",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub transfer_in_count: ::std::option::Option<i64>,
        ///Outbound transfer volume in native token over last 7 days
        #[serde(
            rename = "transferOutAmount7d",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub transfer_out_amount7d: ::std::option::Option<::std::string::String>,
        ///Number of token transfer-out events (GMGN: transfer_out_count)
        #[serde(
            rename = "transferOutCount",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub transfer_out_count: ::std::option::Option<i64>,
        ///Unrealized PnL in USD (current position)
        #[serde(
            rename = "unrealizedProfit",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub unrealized_profit: ::std::option::Option<::std::string::String>,
        ///Holder wallet address
        #[serde(rename = "walletAddress")]
        pub wallet_address: ::std::string::String,
        /**Global rank tag on this token when sorted by balance (e.g. "TOP1", "TOP2").
Only present on the first page of a balance-sorted query (no cursor).*/
        #[serde(
            rename = "walletTagV2",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub wallet_tag_v2: ::std::option::Option<::std::string::String>,
        ///Number of winning trades (PnL > 0)
        #[serde(
            rename = "winCount",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub win_count: ::std::option::Option<i64>,
    }
    impl ::std::convert::From<&TokenHolder> for TokenHolder {
        fn from(value: &TokenHolder) -> Self {
            value.clone()
        }
    }
    impl TokenHolder {
        pub fn builder() -> builder::TokenHolder {
            Default::default()
        }
    }
    ///Single time-point in the holder waterline trend (sparkline data)
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Single time-point in the holder waterline trend (sparkline data)",
    ///  "type": "object",
    ///  "required": [
    ///    "bluechipAmountRatio",
    ///    "bundleAmountRatio",
    ///    "creatorsAmountRatio",
    ///    "devAmountRatio",
    ///    "freshAmountRatio",
    ///    "holders",
    ///    "insiderAmountRatio",
    ///    "kolAmountRatio",
    ///    "phishingAmountRatio",
    ///    "proAmountRatio",
    ///    "ratAmountRatio",
    ///    "sandwichAmountRatio",
    ///    "smartAmountRatio",
    ///    "sniperAmountRatio",
    ///    "timestamp",
    ///    "top100HoldersRatio",
    ///    "top10HoldersRatio",
    ///    "top50HoldersRatio"
    ///  ],
    ///  "properties": {
    ///    "bluechipAmountRatio": {
    ///      "description": "Bluechip holder ratio (0–1)",
    ///      "examples": [
    ///        "0.0200"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "bundleAmountRatio": {
    ///      "description": "Bundle (bundler) wallet holding ratio (0–1)",
    ///      "examples": [
    ///        "0.0006"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "creatorsAmountRatio": {
    ///      "description": "Creator wallet holding ratio (0–1)",
    ///      "examples": [
    ///        "0.0050"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "devAmountRatio": {
    ///      "description": "Dev wallet holding ratio (0–1)",
    ///      "examples": [
    ///        "0.0100"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "freshAmountRatio": {
    ///      "description": "Fresh wallet holding ratio (0–1)",
    ///      "examples": [
    ///        "0.1500"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "holders": {
    ///      "description": "Total holder count",
    ///      "examples": [
    ///        "644381"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "insiderAmountRatio": {
    ///      "description": "Insider wallet holding ratio (0–1)",
    ///      "examples": [
    ///        "0.0200"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "kolAmountRatio": {
    ///      "description": "KOL wallet holding ratio (0–1)",
    ///      "examples": [
    ///        "0.0300"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "phishingAmountRatio": {
    ///      "description": "Phishing (entrapment) wallet holding ratio (0–1)",
    ///      "examples": [
    ///        "0.1400"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "proAmountRatio": {
    ///      "description": "Pro wallet holding ratio (0–1)",
    ///      "examples": [
    ///        "0.0300"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "ratAmountRatio": {
    ///      "description": "Rat trader holding ratio (0–1)",
    ///      "examples": [
    ///        "0.0001"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "sandwichAmountRatio": {
    ///      "description": "Sandwich bot holding ratio (0–1)",
    ///      "examples": [
    ///        "0.0020"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "smartAmountRatio": {
    ///      "description": "Smart wallet holding ratio (0–1)",
    ///      "examples": [
    ///        "0.0800"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "sniperAmountRatio": {
    ///      "description": "Sniper wallet holding ratio (0–1)",
    ///      "examples": [
    ///        "0.0050"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "timestamp": {
    ///      "description": "Unix timestamp in milliseconds (start of the hour or day bucket)",
    ///      "examples": [
    ///        1747353600000
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "top100HoldersRatio": {
    ///      "description": "Top-100 holder ratio (0–1)",
    ///      "examples": [
    ///        "0.2500"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "top10HoldersRatio": {
    ///      "description": "Top-10 holder ratio (0–1)",
    ///      "examples": [
    ///        "0.0832"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "top50HoldersRatio": {
    ///      "description": "Top-50 holder ratio (0–1)",
    ///      "examples": [
    ///        "0.1500"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct TokenHolderTrendPoint {
        ///Bluechip holder ratio (0–1)
        #[serde(rename = "bluechipAmountRatio")]
        pub bluechip_amount_ratio: ::std::string::String,
        ///Bundle (bundler) wallet holding ratio (0–1)
        #[serde(rename = "bundleAmountRatio")]
        pub bundle_amount_ratio: ::std::string::String,
        ///Creator wallet holding ratio (0–1)
        #[serde(rename = "creatorsAmountRatio")]
        pub creators_amount_ratio: ::std::string::String,
        ///Dev wallet holding ratio (0–1)
        #[serde(rename = "devAmountRatio")]
        pub dev_amount_ratio: ::std::string::String,
        ///Fresh wallet holding ratio (0–1)
        #[serde(rename = "freshAmountRatio")]
        pub fresh_amount_ratio: ::std::string::String,
        ///Total holder count
        pub holders: ::std::string::String,
        ///Insider wallet holding ratio (0–1)
        #[serde(rename = "insiderAmountRatio")]
        pub insider_amount_ratio: ::std::string::String,
        ///KOL wallet holding ratio (0–1)
        #[serde(rename = "kolAmountRatio")]
        pub kol_amount_ratio: ::std::string::String,
        ///Phishing (entrapment) wallet holding ratio (0–1)
        #[serde(rename = "phishingAmountRatio")]
        pub phishing_amount_ratio: ::std::string::String,
        ///Pro wallet holding ratio (0–1)
        #[serde(rename = "proAmountRatio")]
        pub pro_amount_ratio: ::std::string::String,
        ///Rat trader holding ratio (0–1)
        #[serde(rename = "ratAmountRatio")]
        pub rat_amount_ratio: ::std::string::String,
        ///Sandwich bot holding ratio (0–1)
        #[serde(rename = "sandwichAmountRatio")]
        pub sandwich_amount_ratio: ::std::string::String,
        ///Smart wallet holding ratio (0–1)
        #[serde(rename = "smartAmountRatio")]
        pub smart_amount_ratio: ::std::string::String,
        ///Sniper wallet holding ratio (0–1)
        #[serde(rename = "sniperAmountRatio")]
        pub sniper_amount_ratio: ::std::string::String,
        ///Unix timestamp in milliseconds (start of the hour or day bucket)
        pub timestamp: i64,
        ///Top-100 holder ratio (0–1)
        #[serde(rename = "top100HoldersRatio")]
        pub top100_holders_ratio: ::std::string::String,
        ///Top-10 holder ratio (0–1)
        #[serde(rename = "top10HoldersRatio")]
        pub top10_holders_ratio: ::std::string::String,
        ///Top-50 holder ratio (0–1)
        #[serde(rename = "top50HoldersRatio")]
        pub top50_holders_ratio: ::std::string::String,
    }
    impl ::std::convert::From<&TokenHolderTrendPoint> for TokenHolderTrendPoint {
        fn from(value: &TokenHolderTrendPoint) -> Self {
            value.clone()
        }
    }
    impl TokenHolderTrendPoint {
        pub fn builder() -> builder::TokenHolderTrendPoint {
            Default::default()
        }
    }
    ///Token liquidity snapshot
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Token liquidity snapshot",
    ///  "type": "object",
    ///  "required": [
    ///    "calculatedAt",
    ///    "maxLiquidityInNative",
    ///    "maxLiquidityInUsd",
    ///    "maxLiquidityPoolAddress",
    ///    "poolCount",
    ///    "priceNative",
    ///    "priceUsd",
    ///    "snapshotTime",
    ///    "totalLiquidityInNative",
    ///    "totalLiquidityInUsd"
    ///  ],
    ///  "properties": {
    ///    "calculatedAt": {
    ///      "description": "Snapshot calculation timestamp (milliseconds)",
    ///      "examples": [
    ///        1705312800000
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "maxLiquidityInNative": {
    ///      "description": "Maximum pool liquidity in native token",
    ///      "examples": [
    ///        "5000.123"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "maxLiquidityInUsd": {
    ///      "description": "Maximum pool liquidity in USD",
    ///      "examples": [
    ///        "1000000.45"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "maxLiquidityPoolAddress": {
    ///      "description": "Address of the pool with maximum liquidity",
    ///      "examples": [
    ///        "58oQChx4yWmvKdwLLZzBi4ChoCc2fqCUWBkwMihLYQo2"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "poolCount": {
    ///      "description": "Number of active liquidity pools",
    ///      "examples": [
    ///        5
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "priceNative": {
    ///      "description": "Token price in native token at snapshot time",
    ///      "examples": [
    ///        "0.005"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "priceUsd": {
    ///      "description": "Token price in USD at snapshot time",
    ///      "examples": [
    ///        "1.0001"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "snapshotTime": {
    ///      "description": "Snapshot timestamp (milliseconds)",
    ///      "examples": [
    ///        1705312800000
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "totalLiquidityInNative": {
    ///      "description": "Total liquidity across all pools in native token",
    ///      "examples": [
    ///        "10000.246"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "totalLiquidityInUsd": {
    ///      "description": "Total liquidity across all pools in USD",
    ///      "examples": [
    ///        "2000000.90"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct TokenLiquiditySnapshot {
        ///Snapshot calculation timestamp (milliseconds)
        #[serde(rename = "calculatedAt")]
        pub calculated_at: i64,
        ///Maximum pool liquidity in native token
        #[serde(rename = "maxLiquidityInNative")]
        pub max_liquidity_in_native: ::std::string::String,
        ///Maximum pool liquidity in USD
        #[serde(rename = "maxLiquidityInUsd")]
        pub max_liquidity_in_usd: ::std::string::String,
        ///Address of the pool with maximum liquidity
        #[serde(rename = "maxLiquidityPoolAddress")]
        pub max_liquidity_pool_address: ::std::string::String,
        ///Number of active liquidity pools
        #[serde(rename = "poolCount")]
        pub pool_count: i64,
        ///Token price in native token at snapshot time
        #[serde(rename = "priceNative")]
        pub price_native: ::std::string::String,
        ///Token price in USD at snapshot time
        #[serde(rename = "priceUsd")]
        pub price_usd: ::std::string::String,
        ///Snapshot timestamp (milliseconds)
        #[serde(rename = "snapshotTime")]
        pub snapshot_time: i64,
        ///Total liquidity across all pools in native token
        #[serde(rename = "totalLiquidityInNative")]
        pub total_liquidity_in_native: ::std::string::String,
        ///Total liquidity across all pools in USD
        #[serde(rename = "totalLiquidityInUsd")]
        pub total_liquidity_in_usd: ::std::string::String,
    }
    impl ::std::convert::From<&TokenLiquiditySnapshot> for TokenLiquiditySnapshot {
        fn from(value: &TokenLiquiditySnapshot) -> Self {
            value.clone()
        }
    }
    impl TokenLiquiditySnapshot {
        pub fn builder() -> builder::TokenLiquiditySnapshot {
            Default::default()
        }
    }
    ///`TokenListSortField`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "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 TokenListSortField {
        #[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 TokenListSortField {
        fn from(value: &TokenListSortField) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for TokenListSortField {
        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 TokenListSortField {
        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 TokenListSortField {
        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 TokenListSortField {
        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 TokenListSortField {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    ///Token market data
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Token market data",
    ///  "type": "object",
    ///  "properties": {
    ///    "athMarketCapInUsd": {
    ///      "description": "ENTITY.TOKEN_MARKET_DATA.ATH_MARKET_CAP_IN_USD\nAll-time-high market cap in USD (max observed since token creation).",
    ///      "examples": [
    ///        "9500000.00"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "bluechipHoldingsRatio": {
    ///      "description": "Ratio of bluechip holdings to total supply",
    ///      "examples": [
    ///        "0.05"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "bluechipTotalHolders": {
    ///      "description": "Number of bluechip wallet holders",
    ///      "examples": [
    ///        "10"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "bluechipTotalHoldings": {
    ///      "description": "Total holdings of bluechip wallets",
    ///      "examples": [
    ///        "50000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "bundleHoldingsRatio": {
    ///      "description": "Ratio of bundle holdings to total supply",
    ///      "examples": [
    ///        "0.018"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "bundleTotalHolders": {
    ///      "description": "Number of bundle wallet holders",
    ///      "examples": [
    ///        "12"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "bundleTotalHoldings": {
    ///      "description": "Total holdings of bundle wallets",
    ///      "examples": [
    ///        "18000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "circulatingSupply": {
    ///      "description": "Circulating supply of the token",
    ///      "examples": [
    ///        "900000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "completionRatio": {
    ///      "description": "Bonding curve completion ratio",
    ///      "examples": [
    ///        "1.0"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "creatorsHoldingsRatio": {
    ///      "description": "ENTITY.TOKEN_MARKET_DATA.CREATORS_HOLDINGS_RATIO",
    ///      "examples": [
    ///        "0.10"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "creatorsTotalHolders": {
    ///      "description": "ENTITY.TOKEN_MARKET_DATA.CREATORS_TOTAL_HOLDERS",
    ///      "examples": [
    ///        "1"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "creatorsTotalHoldings": {
    ///      "description": "ENTITY.TOKEN_MARKET_DATA.CREATORS_TOTAL_HOLDINGS",
    ///      "examples": [
    ///        "100000000.00"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "devHoldingsRatio": {
    ///      "description": "Ratio of developer holdings to total supply",
    ///      "examples": [
    ///        "0.005"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "devTotalHolders": {
    ///      "description": "Number of developer wallet holders",
    ///      "examples": [
    ///        "3"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "devTotalHoldings": {
    ///      "description": "Total holdings of developer wallets",
    ///      "examples": [
    ///        "5000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "fdvInSol": {
    ///      "description": "Fully diluted valuation in native token",
    ///      "examples": [
    ///        "200000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "fdvInUsd": {
    ///      "description": "Fully diluted valuation in USD",
    ///      "examples": [
    ///        "200000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "freshHoldingsRatio": {
    ///      "description": "Ratio of fresh wallet holdings to total supply",
    ///      "examples": [
    ///        "0.01"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "freshTotalHolders": {
    ///      "description": "Number of fresh (new) wallet holders",
    ///      "examples": [
    ///        "30"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "freshTotalHoldings": {
    ///      "description": "Total holdings of fresh wallets",
    ///      "examples": [
    ///        "10000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "holders": {
    ///      "description": "Total number of token holders",
    ///      "examples": [
    ///        "1000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "insiderHoldingsRatio": {
    ///      "description": "Ratio of insider holdings to total supply",
    ///      "examples": [
    ///        "0.02"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "insiderTotalHolders": {
    ///      "description": "Number of insider wallet holders",
    ///      "examples": [
    ///        "5"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "insiderTotalHoldings": {
    ///      "description": "Total holdings of insider wallets",
    ///      "examples": [
    ///        "20000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "kolHoldingsRatio": {
    ///      "description": "Ratio of KOL holdings to total supply",
    ///      "examples": [
    ///        "0.03"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "kolTotalHolders": {
    ///      "description": "Number of KOL (Key Opinion Leader) holders",
    ///      "examples": [
    ///        "20"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "kolTotalHoldings": {
    ///      "description": "Total holdings of KOL wallets",
    ///      "examples": [
    ///        "30000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "marketCapInSol": {
    ///      "description": "Market capitalization in native token",
    ///      "examples": [
    ///        "100000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "marketCapInUsd": {
    ///      "description": "Market capitalization in USD",
    ///      "examples": [
    ///        "100000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "maxPoolTvlInSol": {
    ///      "description": "Maximum pool TVL in native token",
    ///      "examples": [
    ///        "1000.45"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "maxPoolTvlInUsd": {
    ///      "description": "Maximum pool TVL in USD",
    ///      "examples": [
    ///        "150000.00"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "phishingHoldingsRatio": {
    ///      "description": "ENTITY.TOKEN_MARKET_DATA.PHISHING_HOLDINGS_RATIO",
    ///      "examples": [
    ///        "0.0005"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "phishingTotalHolders": {
    ///      "description": "ENTITY.TOKEN_MARKET_DATA.PHISHING_TOTAL_HOLDERS",
    ///      "examples": [
    ///        "2"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "phishingTotalHoldings": {
    ///      "description": "ENTITY.TOKEN_MARKET_DATA.PHISHING_TOTAL_HOLDINGS",
    ///      "examples": [
    ///        "50000.00"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "priceInSol": {
    ///      "description": "Token price in native token",
    ///      "examples": [
    ///        "0.00000261383847574915906643405542"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "priceInUsd": {
    ///      "description": "Token price in USD",
    ///      "examples": [
    ///        "0.00000261383847574915906643405542"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "proHoldingsRatio": {
    ///      "description": "Ratio of professional trader holdings to total supply",
    ///      "examples": [
    ///        "0.04"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "proTotalHolders": {
    ///      "description": "Number of professional trader holders",
    ///      "examples": [
    ///        "25"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "proTotalHoldings": {
    ///      "description": "Total holdings of professional traders",
    ///      "examples": [
    ///        "40000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "ratHoldingsRatio": {
    ///      "description": "ENTITY.TOKEN_MARKET_DATA.RAT_HOLDINGS_RATIO",
    ///      "examples": [
    ///        "0.0012"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "ratTotalHolders": {
    ///      "description": "ENTITY.TOKEN_MARKET_DATA.RAT_TOTAL_HOLDERS",
    ///      "examples": [
    ///        "5"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "ratTotalHoldings": {
    ///      "description": "ENTITY.TOKEN_MARKET_DATA.RAT_TOTAL_HOLDINGS",
    ///      "examples": [
    ///        "120000.00"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "sandwishHoldingsRatio": {
    ///      "description": "Ratio of sandwich attack holdings to total supply",
    ///      "examples": [
    ///        "0.015"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "sandwishTotalHolders": {
    ///      "description": "Number of sandwich attack wallet holders",
    ///      "examples": [
    ///        "8"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "sandwishTotalHoldings": {
    ///      "description": "Total holdings of sandwich attack wallets",
    ///      "examples": [
    ///        "15000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "smartHoldingsRatio": {
    ///      "description": "ENTITY.TOKEN_MARKET_DATA.SMART_HOLDINGS_RATIO",
    ///      "examples": [
    ///        "0.03"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "smartTotalHolders": {
    ///      "description": "ENTITY.TOKEN_MARKET_DATA.SMART_TOTAL_HOLDERS",
    ///      "examples": [
    ///        "30"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "smartTotalHoldings": {
    ///      "description": "ENTITY.TOKEN_MARKET_DATA.SMART_TOTAL_HOLDINGS",
    ///      "examples": [
    ///        "3000000.00"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "sniperHoldingsRatio": {
    ///      "description": "Ratio of sniper holdings to total supply",
    ///      "examples": [
    ///        "0.025"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "sniperTotalHolders": {
    ///      "description": "Number of sniper wallet holders",
    ///      "examples": [
    ///        "15"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "sniperTotalHoldings": {
    ///      "description": "Total holdings of sniper wallets",
    ///      "examples": [
    ///        "25000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "top100HoldingsRatio": {
    ///      "description": "Ratio of top 100 holders to total supply",
    ///      "examples": [
    ///        "0.8"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "top100TotalHoldings": {
    ///      "description": "Total holdings of top 100 holders",
    ///      "examples": [
    ///        "800000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "top10HoldingsRatio": {
    ///      "description": "Ratio of top 10 holders to total supply",
    ///      "examples": [
    ///        "0.5"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "top10TotalHoldings": {
    ///      "description": "Total holdings of top 10 holders",
    ///      "examples": [
    ///        "500000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "top50HoldingsRatio": {
    ///      "description": "Ratio of top 50 holders to total supply",
    ///      "examples": [
    ///        "0.3"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "top50TotalHoldings": {
    ///      "description": "Total holdings of top 50 holders",
    ///      "examples": [
    ///        "300000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "totalSupply": {
    ///      "description": "Total supply of the token",
    ///      "examples": [
    ///        "1000000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "totalTvlInSol": {
    ///      "description": "Total value locked in native token",
    ///      "examples": [
    ///        "1000000.45"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "totalTvlInUsd": {
    ///      "description": "Total value locked in USD",
    ///      "examples": [
    ///        "1000000.45"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct TokenMarketData {
        /**ENTITY.TOKEN_MARKET_DATA.ATH_MARKET_CAP_IN_USD
All-time-high market cap in USD (max observed since token creation).*/
        #[serde(
            rename = "athMarketCapInUsd",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub ath_market_cap_in_usd: ::std::option::Option<::std::string::String>,
        ///Ratio of bluechip holdings to total supply
        #[serde(
            rename = "bluechipHoldingsRatio",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub bluechip_holdings_ratio: ::std::option::Option<::std::string::String>,
        ///Number of bluechip wallet holders
        #[serde(
            rename = "bluechipTotalHolders",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub bluechip_total_holders: ::std::option::Option<::std::string::String>,
        ///Total holdings of bluechip wallets
        #[serde(
            rename = "bluechipTotalHoldings",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub bluechip_total_holdings: ::std::option::Option<::std::string::String>,
        ///Ratio of bundle holdings to total supply
        #[serde(
            rename = "bundleHoldingsRatio",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub bundle_holdings_ratio: ::std::option::Option<::std::string::String>,
        ///Number of bundle wallet holders
        #[serde(
            rename = "bundleTotalHolders",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub bundle_total_holders: ::std::option::Option<::std::string::String>,
        ///Total holdings of bundle wallets
        #[serde(
            rename = "bundleTotalHoldings",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub bundle_total_holdings: ::std::option::Option<::std::string::String>,
        ///Circulating supply of the token
        #[serde(
            rename = "circulatingSupply",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub circulating_supply: ::std::option::Option<::std::string::String>,
        ///Bonding curve completion ratio
        #[serde(
            rename = "completionRatio",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub completion_ratio: ::std::option::Option<::std::string::String>,
        ///ENTITY.TOKEN_MARKET_DATA.CREATORS_HOLDINGS_RATIO
        #[serde(
            rename = "creatorsHoldingsRatio",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub creators_holdings_ratio: ::std::option::Option<::std::string::String>,
        ///ENTITY.TOKEN_MARKET_DATA.CREATORS_TOTAL_HOLDERS
        #[serde(
            rename = "creatorsTotalHolders",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub creators_total_holders: ::std::option::Option<::std::string::String>,
        ///ENTITY.TOKEN_MARKET_DATA.CREATORS_TOTAL_HOLDINGS
        #[serde(
            rename = "creatorsTotalHoldings",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub creators_total_holdings: ::std::option::Option<::std::string::String>,
        ///Ratio of developer holdings to total supply
        #[serde(
            rename = "devHoldingsRatio",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub dev_holdings_ratio: ::std::option::Option<::std::string::String>,
        ///Number of developer wallet holders
        #[serde(
            rename = "devTotalHolders",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub dev_total_holders: ::std::option::Option<::std::string::String>,
        ///Total holdings of developer wallets
        #[serde(
            rename = "devTotalHoldings",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub dev_total_holdings: ::std::option::Option<::std::string::String>,
        ///Fully diluted valuation in native token
        #[serde(
            rename = "fdvInSol",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub fdv_in_sol: ::std::option::Option<::std::string::String>,
        ///Fully diluted valuation in USD
        #[serde(
            rename = "fdvInUsd",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub fdv_in_usd: ::std::option::Option<::std::string::String>,
        ///Ratio of fresh wallet holdings to total supply
        #[serde(
            rename = "freshHoldingsRatio",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub fresh_holdings_ratio: ::std::option::Option<::std::string::String>,
        ///Number of fresh (new) wallet holders
        #[serde(
            rename = "freshTotalHolders",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub fresh_total_holders: ::std::option::Option<::std::string::String>,
        ///Total holdings of fresh wallets
        #[serde(
            rename = "freshTotalHoldings",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub fresh_total_holdings: ::std::option::Option<::std::string::String>,
        ///Total number of token holders
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub holders: ::std::option::Option<::std::string::String>,
        ///Ratio of insider holdings to total supply
        #[serde(
            rename = "insiderHoldingsRatio",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub insider_holdings_ratio: ::std::option::Option<::std::string::String>,
        ///Number of insider wallet holders
        #[serde(
            rename = "insiderTotalHolders",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub insider_total_holders: ::std::option::Option<::std::string::String>,
        ///Total holdings of insider wallets
        #[serde(
            rename = "insiderTotalHoldings",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub insider_total_holdings: ::std::option::Option<::std::string::String>,
        ///Ratio of KOL holdings to total supply
        #[serde(
            rename = "kolHoldingsRatio",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub kol_holdings_ratio: ::std::option::Option<::std::string::String>,
        ///Number of KOL (Key Opinion Leader) holders
        #[serde(
            rename = "kolTotalHolders",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub kol_total_holders: ::std::option::Option<::std::string::String>,
        ///Total holdings of KOL wallets
        #[serde(
            rename = "kolTotalHoldings",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub kol_total_holdings: ::std::option::Option<::std::string::String>,
        ///Market capitalization in native token
        #[serde(
            rename = "marketCapInSol",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub market_cap_in_sol: ::std::option::Option<::std::string::String>,
        ///Market capitalization in USD
        #[serde(
            rename = "marketCapInUsd",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub market_cap_in_usd: ::std::option::Option<::std::string::String>,
        ///Maximum pool TVL in native token
        #[serde(
            rename = "maxPoolTvlInSol",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub max_pool_tvl_in_sol: ::std::option::Option<::std::string::String>,
        ///Maximum 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>,
        ///ENTITY.TOKEN_MARKET_DATA.PHISHING_HOLDINGS_RATIO
        #[serde(
            rename = "phishingHoldingsRatio",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub phishing_holdings_ratio: ::std::option::Option<::std::string::String>,
        ///ENTITY.TOKEN_MARKET_DATA.PHISHING_TOTAL_HOLDERS
        #[serde(
            rename = "phishingTotalHolders",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub phishing_total_holders: ::std::option::Option<::std::string::String>,
        ///ENTITY.TOKEN_MARKET_DATA.PHISHING_TOTAL_HOLDINGS
        #[serde(
            rename = "phishingTotalHoldings",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub phishing_total_holdings: ::std::option::Option<::std::string::String>,
        ///Token price in native token
        #[serde(
            rename = "priceInSol",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub price_in_sol: ::std::option::Option<::std::string::String>,
        ///Token price in USD
        #[serde(
            rename = "priceInUsd",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub price_in_usd: ::std::option::Option<::std::string::String>,
        ///Ratio of professional trader holdings to total supply
        #[serde(
            rename = "proHoldingsRatio",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub pro_holdings_ratio: ::std::option::Option<::std::string::String>,
        ///Number of professional trader holders
        #[serde(
            rename = "proTotalHolders",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub pro_total_holders: ::std::option::Option<::std::string::String>,
        ///Total holdings of professional traders
        #[serde(
            rename = "proTotalHoldings",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub pro_total_holdings: ::std::option::Option<::std::string::String>,
        ///ENTITY.TOKEN_MARKET_DATA.RAT_HOLDINGS_RATIO
        #[serde(
            rename = "ratHoldingsRatio",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub rat_holdings_ratio: ::std::option::Option<::std::string::String>,
        ///ENTITY.TOKEN_MARKET_DATA.RAT_TOTAL_HOLDERS
        #[serde(
            rename = "ratTotalHolders",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub rat_total_holders: ::std::option::Option<::std::string::String>,
        ///ENTITY.TOKEN_MARKET_DATA.RAT_TOTAL_HOLDINGS
        #[serde(
            rename = "ratTotalHoldings",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub rat_total_holdings: ::std::option::Option<::std::string::String>,
        ///Ratio of sandwich attack holdings to total supply
        #[serde(
            rename = "sandwishHoldingsRatio",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub sandwish_holdings_ratio: ::std::option::Option<::std::string::String>,
        ///Number of sandwich attack wallet holders
        #[serde(
            rename = "sandwishTotalHolders",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub sandwish_total_holders: ::std::option::Option<::std::string::String>,
        ///Total holdings of sandwich attack wallets
        #[serde(
            rename = "sandwishTotalHoldings",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub sandwish_total_holdings: ::std::option::Option<::std::string::String>,
        ///ENTITY.TOKEN_MARKET_DATA.SMART_HOLDINGS_RATIO
        #[serde(
            rename = "smartHoldingsRatio",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub smart_holdings_ratio: ::std::option::Option<::std::string::String>,
        ///ENTITY.TOKEN_MARKET_DATA.SMART_TOTAL_HOLDERS
        #[serde(
            rename = "smartTotalHolders",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub smart_total_holders: ::std::option::Option<::std::string::String>,
        ///ENTITY.TOKEN_MARKET_DATA.SMART_TOTAL_HOLDINGS
        #[serde(
            rename = "smartTotalHoldings",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub smart_total_holdings: ::std::option::Option<::std::string::String>,
        ///Ratio of sniper holdings to total supply
        #[serde(
            rename = "sniperHoldingsRatio",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub sniper_holdings_ratio: ::std::option::Option<::std::string::String>,
        ///Number of sniper wallet holders
        #[serde(
            rename = "sniperTotalHolders",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub sniper_total_holders: ::std::option::Option<::std::string::String>,
        ///Total holdings of sniper wallets
        #[serde(
            rename = "sniperTotalHoldings",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub sniper_total_holdings: ::std::option::Option<::std::string::String>,
        ///Ratio of top 100 holders to total supply
        #[serde(
            rename = "top100HoldingsRatio",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub top100_holdings_ratio: ::std::option::Option<::std::string::String>,
        ///Total holdings of top 100 holders
        #[serde(
            rename = "top100TotalHoldings",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub top100_total_holdings: ::std::option::Option<::std::string::String>,
        ///Ratio of top 10 holders to total supply
        #[serde(
            rename = "top10HoldingsRatio",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub top10_holdings_ratio: ::std::option::Option<::std::string::String>,
        ///Total holdings of top 10 holders
        #[serde(
            rename = "top10TotalHoldings",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub top10_total_holdings: ::std::option::Option<::std::string::String>,
        ///Ratio of top 50 holders to total supply
        #[serde(
            rename = "top50HoldingsRatio",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub top50_holdings_ratio: ::std::option::Option<::std::string::String>,
        ///Total holdings of top 50 holders
        #[serde(
            rename = "top50TotalHoldings",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub top50_total_holdings: ::std::option::Option<::std::string::String>,
        ///Total supply of the token
        #[serde(
            rename = "totalSupply",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub total_supply: ::std::option::Option<::std::string::String>,
        ///Total value locked in native token
        #[serde(
            rename = "totalTvlInSol",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub total_tvl_in_sol: ::std::option::Option<::std::string::String>,
        ///Total value locked in USD
        #[serde(
            rename = "totalTvlInUsd",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub total_tvl_in_usd: ::std::option::Option<::std::string::String>,
    }
    impl ::std::convert::From<&TokenMarketData> for TokenMarketData {
        fn from(value: &TokenMarketData) -> Self {
            value.clone()
        }
    }
    impl ::std::default::Default for TokenMarketData {
        fn default() -> Self {
            Self {
                ath_market_cap_in_usd: Default::default(),
                bluechip_holdings_ratio: Default::default(),
                bluechip_total_holders: Default::default(),
                bluechip_total_holdings: Default::default(),
                bundle_holdings_ratio: Default::default(),
                bundle_total_holders: Default::default(),
                bundle_total_holdings: Default::default(),
                circulating_supply: Default::default(),
                completion_ratio: Default::default(),
                creators_holdings_ratio: Default::default(),
                creators_total_holders: Default::default(),
                creators_total_holdings: Default::default(),
                dev_holdings_ratio: Default::default(),
                dev_total_holders: Default::default(),
                dev_total_holdings: Default::default(),
                fdv_in_sol: Default::default(),
                fdv_in_usd: Default::default(),
                fresh_holdings_ratio: Default::default(),
                fresh_total_holders: Default::default(),
                fresh_total_holdings: Default::default(),
                holders: Default::default(),
                insider_holdings_ratio: Default::default(),
                insider_total_holders: Default::default(),
                insider_total_holdings: Default::default(),
                kol_holdings_ratio: Default::default(),
                kol_total_holders: Default::default(),
                kol_total_holdings: Default::default(),
                market_cap_in_sol: Default::default(),
                market_cap_in_usd: Default::default(),
                max_pool_tvl_in_sol: Default::default(),
                max_pool_tvl_in_usd: Default::default(),
                phishing_holdings_ratio: Default::default(),
                phishing_total_holders: Default::default(),
                phishing_total_holdings: Default::default(),
                price_in_sol: Default::default(),
                price_in_usd: Default::default(),
                pro_holdings_ratio: Default::default(),
                pro_total_holders: Default::default(),
                pro_total_holdings: Default::default(),
                rat_holdings_ratio: Default::default(),
                rat_total_holders: Default::default(),
                rat_total_holdings: Default::default(),
                sandwish_holdings_ratio: Default::default(),
                sandwish_total_holders: Default::default(),
                sandwish_total_holdings: Default::default(),
                smart_holdings_ratio: Default::default(),
                smart_total_holders: Default::default(),
                smart_total_holdings: Default::default(),
                sniper_holdings_ratio: Default::default(),
                sniper_total_holders: Default::default(),
                sniper_total_holdings: Default::default(),
                top100_holdings_ratio: Default::default(),
                top100_total_holdings: Default::default(),
                top10_holdings_ratio: Default::default(),
                top10_total_holdings: Default::default(),
                top50_holdings_ratio: Default::default(),
                top50_total_holdings: Default::default(),
                total_supply: Default::default(),
                total_tvl_in_sol: Default::default(),
                total_tvl_in_usd: Default::default(),
            }
        }
    }
    impl TokenMarketData {
        pub fn builder() -> builder::TokenMarketData {
            Default::default()
        }
    }
    ///Token metadata
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Token metadata",
    ///  "type": "object",
    ///  "required": [
    ///    "address",
    ///    "chain",
    ///    "decimals",
    ///    "name",
    ///    "symbol"
    ///  ],
    ///  "properties": {
    ///    "address": {
    ///      "description": "Token contract address",
    ///      "examples": [
    ///        "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "chain": {
    ///      "description": "Blockchain network identifier",
    ///      "examples": [
    ///        "sol"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "coingeckoCoinId": {
    ///      "description": "CoinGecko coin identifier",
    ///      "examples": [
    ///        "usd-coin"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "decimals": {
    ///      "description": "Number of decimal places",
    ///      "examples": [
    ///        "9"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "description": {
    ///      "description": "Token description",
    ///      "examples": [
    ///        "USDC is a stablecoin pegged to the US dollar"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "devLastTokenCreatedAt": {
    ///      "description": "Timestamp of developer last token creation",
    ///      "examples": [
    ///        "2025-12-03T09:23:34.000Z"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "devTotalTokens": {
    ///      "description": "Total number of tokens created by the developer",
    ///      "examples": [
    ///        "163"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "extra": {
    ///      "$ref": "#/components/schemas/TokenExtra"
    ///    },
    ///    "imageUrl": {
    ///      "description": "Token logo image URL",
    ///      "examples": [
    ///        "https://raw.githubusercontent.com/solana-labs/token-list/main/assets/mainnet/EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v/logo.png"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "metadataAddress": {
    ///      "description": "On-chain metadata account address",
    ///      "examples": [
    ///        "metaqbxxUerdq28cj1RbAWkYQm3ybzjb6a8bt518x1s"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "name": {
    ///      "description": "Token display name",
    ///      "examples": [
    ///        "USD Coin"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "socialMedias": {
    ///      "$ref": "#/components/schemas/TokenSocialMedias"
    ///    },
    ///    "symbol": {
    ///      "description": "Token ticker symbol",
    ///      "examples": [
    ///        "USDC"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "tokenCreatedAt": {
    ///      "description": "Token creation timestamp (milliseconds)",
    ///      "examples": [
    ///        1710417600000
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "tokenCreatedBlockHeight": {
    ///      "description": "Block height when token was created",
    ///      "examples": [
    ///        "220000000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "tokenCreatedSlot": {
    ///      "description": "Slot number when token was created",
    ///      "examples": [
    ///        "230000000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "tokenCreatedTxSignature": {
    ///      "description": "Transaction signature of token creation",
    ///      "examples": [
    ///        "5dJ1BxPiFT7w7aBdkxNy2jopGZnZoLwRwS8e9GkEXrVz..."
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "tokenCreators": {
    ///      "description": "List of token creators",
    ///      "type": "array",
    ///      "items": {
    ///        "$ref": "#/components/schemas/TokenCreator"
    ///      }
    ///    },
    ///    "updatedAt": {
    ///      "description": "Last updated timestamp",
    ///      "examples": [
    ///        "2026-02-09T08:05:12.345Z"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "uri": {
    ///      "description": "Token metadata URI",
    ///      "examples": [
    ///        "https://arweave.net/abc123"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct TokenMetadata {
        ///Token contract address
        pub address: ::std::string::String,
        ///Blockchain network identifier
        pub chain: ::std::string::String,
        ///CoinGecko coin identifier
        #[serde(
            rename = "coingeckoCoinId",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub coingecko_coin_id: ::std::option::Option<::std::string::String>,
        ///Number of decimal places
        pub decimals: ::std::string::String,
        ///Token description
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub description: ::std::option::Option<::std::string::String>,
        ///Timestamp of developer last token creation
        #[serde(
            rename = "devLastTokenCreatedAt",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub dev_last_token_created_at: ::std::option::Option<::std::string::String>,
        ///Total number of tokens created by the developer
        #[serde(
            rename = "devTotalTokens",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub dev_total_tokens: ::std::option::Option<::std::string::String>,
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub extra: ::std::option::Option<TokenExtra>,
        ///Token logo image URL
        #[serde(
            rename = "imageUrl",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub image_url: ::std::option::Option<::std::string::String>,
        ///On-chain metadata account address
        #[serde(
            rename = "metadataAddress",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub metadata_address: ::std::option::Option<::std::string::String>,
        ///Token display name
        pub name: ::std::string::String,
        #[serde(
            rename = "socialMedias",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub social_medias: ::std::option::Option<TokenSocialMedias>,
        ///Token ticker symbol
        pub symbol: ::std::string::String,
        ///Token creation timestamp (milliseconds)
        #[serde(
            rename = "tokenCreatedAt",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub token_created_at: ::std::option::Option<i64>,
        ///Block height when token was created
        #[serde(
            rename = "tokenCreatedBlockHeight",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub token_created_block_height: ::std::option::Option<::std::string::String>,
        ///Slot number when token was created
        #[serde(
            rename = "tokenCreatedSlot",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub token_created_slot: ::std::option::Option<::std::string::String>,
        ///Transaction signature of token creation
        #[serde(
            rename = "tokenCreatedTxSignature",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub token_created_tx_signature: ::std::option::Option<::std::string::String>,
        ///List of token creators
        #[serde(
            rename = "tokenCreators",
            default,
            skip_serializing_if = "::std::vec::Vec::is_empty"
        )]
        pub token_creators: ::std::vec::Vec<TokenCreator>,
        ///Last updated timestamp
        #[serde(
            rename = "updatedAt",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub updated_at: ::std::option::Option<::std::string::String>,
        ///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()
        }
    }
    ///Token mint/burn event
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Token mint/burn event",
    ///  "type": "object",
    ///  "required": [
    ///    "amount",
    ///    "blockHeight",
    ///    "blockTimestamp",
    ///    "mintBurnType",
    ///    "tokenAddress",
    ///    "transactionSignature"
    ///  ],
    ///  "properties": {
    ///    "amount": {
    ///      "description": "Mint/burn amount",
    ///      "examples": [
    ///        "1000000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "blockHeight": {
    ///      "description": "Block height",
    ///      "examples": [
    ///        123456789
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "blockTimestamp": {
    ///      "description": "Block timestamp (milliseconds)",
    ///      "examples": [
    ///        1710417600000
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "mintBurnType": {
    ///      "$ref": "#/components/schemas/MintBurnType"
    ///    },
    ///    "tokenAddress": {
    ///      "description": "Token contract address",
    ///      "examples": [
    ///        "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "transactionSignature": {
    ///      "description": "Transaction signature",
    ///      "examples": [
    ///        "3A7B9C1D2E4F6G8"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct TokenMintBurn {
        ///Mint/burn amount
        pub amount: ::std::string::String,
        ///Block height
        #[serde(rename = "blockHeight")]
        pub block_height: i64,
        ///Block timestamp (milliseconds)
        #[serde(rename = "blockTimestamp")]
        pub block_timestamp: i64,
        #[serde(rename = "mintBurnType")]
        pub mint_burn_type: MintBurnType,
        ///Token contract address
        #[serde(rename = "tokenAddress")]
        pub token_address: ::std::string::String,
        ///Transaction signature
        #[serde(rename = "transactionSignature")]
        pub transaction_signature: ::std::string::String,
    }
    impl ::std::convert::From<&TokenMintBurn> for TokenMintBurn {
        fn from(value: &TokenMintBurn) -> Self {
            value.clone()
        }
    }
    impl TokenMintBurn {
        pub fn builder() -> builder::TokenMintBurn {
            Default::default()
        }
    }
    ///Token search result page — mirrors TS `TokenPage`.
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Token search result page — mirrors TS `TokenPage`.",
    ///  "type": "object",
    ///  "required": [
    ///    "data"
    ///  ],
    ///  "properties": {
    ///    "data": {
    ///      "description": "List of tokens",
    ///      "type": "array",
    ///      "items": {
    ///        "$ref": "#/components/schemas/Token"
    ///      }
    ///    },
    ///    "endCursor": {
    ///      "description": "Cursor for the end of current page",
    ///      "examples": [
    ///        "eyJpZCI6ImVuZCJ9"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "hasNext": {
    ///      "description": "Whether there is a next page",
    ///      "examples": [
    ///        false
    ///      ],
    ///      "type": "boolean"
    ///    },
    ///    "hasPrev": {
    ///      "description": "Whether there is a previous page",
    ///      "examples": [
    ///        false
    ///      ],
    ///      "type": "boolean"
    ///    },
    ///    "startCursor": {
    ///      "description": "Cursor for the start of current page",
    ///      "examples": [
    ///        "eyJpZCI6InN0YXJ0In0="
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct TokenPage {
        ///List of tokens
        pub data: ::std::vec::Vec<Token>,
        ///Cursor for the end of current page
        #[serde(
            rename = "endCursor",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub end_cursor: ::std::option::Option<::std::string::String>,
        ///Whether there is a next page
        #[serde(
            rename = "hasNext",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub has_next: ::std::option::Option<bool>,
        ///Whether there is a previous page
        #[serde(
            rename = "hasPrev",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub has_prev: ::std::option::Option<bool>,
        ///Cursor for the start of current page
        #[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<&TokenPage> for TokenPage {
        fn from(value: &TokenPage) -> Self {
            value.clone()
        }
    }
    impl TokenPage {
        pub fn builder() -> builder::TokenPage {
            Default::default()
        }
    }
    ///Token price
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Token price",
    ///  "type": "object",
    ///  "required": [
    ///    "address",
    ///    "priceInUsd",
    ///    "timestamp"
    ///  ],
    ///  "properties": {
    ///    "address": {
    ///      "description": "Token address",
    ///      "examples": [
    ///        "6p6xgHyF7AeE6TZkSmFsko444wqoP15icUSqi2jfGiPN"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "priceInSol": {
    ///      "description": "Price in native token",
    ///      "examples": [
    ///        "1000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "priceInUsd": {
    ///      "description": "Price in USD",
    ///      "examples": [
    ///        "1000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "timestamp": {
    ///      "description": "Timestamp",
    ///      "examples": [
    ///        1754055151000
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct TokenPrice {
        ///Token address
        pub address: ::std::string::String,
        ///Price in native token
        #[serde(
            rename = "priceInSol",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub price_in_sol: ::std::option::Option<::std::string::String>,
        ///Price in USD
        #[serde(rename = "priceInUsd")]
        pub price_in_usd: ::std::string::String,
        ///Timestamp
        pub timestamp: i64,
    }
    impl ::std::convert::From<&TokenPrice> for TokenPrice {
        fn from(value: &TokenPrice) -> Self {
            value.clone()
        }
    }
    impl TokenPrice {
        pub fn builder() -> builder::TokenPrice {
            Default::default()
        }
    }
    ///`TokenSecurityResponse`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "address",
    ///    "chain"
    ///  ],
    ///  "properties": {
    ///    "address": {
    ///      "description": "Token contract address",
    ///      "examples": [
    ///        "6p6xgHyF7AeE6TZkSmFsko444wqoP15icUSqi2jfGiPN"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "chain": {
    ///      "description": "Chain name",
    ///      "examples": [
    ///        "sol"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "goplus": {
    ///      "$ref": "#/components/schemas/GoPlusSecurityInfo"
    ///    },
    ///    "honeypot": {
    ///      "$ref": "#/components/schemas/HoneypotIsSecurityInfo"
    ///    },
    ///    "serialized": {
    ///      "$ref": "#/components/schemas/SerializedSecurityInfo"
    ///    },
    ///    "sourcesAvailable": {
    ///      "description": "ENTITY.TOKEN_SECURITY.SOURCES_AVAILABLE",
    ///      "examples": [
    ///        [
    ///          "goplus"
    ///        ]
    ///      ],
    ///      "type": "array",
    ///      "items": {
    ///        "type": "string"
    ///      }
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct TokenSecurityResponse {
        ///Token contract address
        pub address: ::std::string::String,
        ///Chain name
        pub chain: ::std::string::String,
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub goplus: ::std::option::Option<GoPlusSecurityInfo>,
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub honeypot: ::std::option::Option<HoneypotIsSecurityInfo>,
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub serialized: ::std::option::Option<SerializedSecurityInfo>,
        ///ENTITY.TOKEN_SECURITY.SOURCES_AVAILABLE
        #[serde(
            rename = "sourcesAvailable",
            default,
            skip_serializing_if = "::std::vec::Vec::is_empty"
        )]
        pub sources_available: ::std::vec::Vec<::std::string::String>,
    }
    impl ::std::convert::From<&TokenSecurityResponse> for TokenSecurityResponse {
        fn from(value: &TokenSecurityResponse) -> Self {
            value.clone()
        }
    }
    impl TokenSecurityResponse {
        pub fn builder() -> builder::TokenSecurityResponse {
            Default::default()
        }
    }
    ///Token social media links
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Token social media links",
    ///  "type": "object",
    ///  "properties": {
    ///    "bitbucket": {
    ///      "description": "Bitbucket repository URL",
    ///      "examples": [
    ///        "https://bitbucket.org/circle"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "discord": {
    ///      "description": "Discord server URL",
    ///      "examples": [
    ///        "https://discord.gg/circle"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "facebook": {
    ///      "description": "Facebook page URL",
    ///      "examples": [
    ///        "https://facebook.com/circle"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "github": {
    ///      "description": "GitHub repository URL",
    ///      "examples": [
    ///        "https://github.com/circle"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "instagram": {
    ///      "description": "Instagram handle",
    ///      "examples": [
    ///        "@circle"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "linkedin": {
    ///      "description": "LinkedIn page URL",
    ///      "examples": [
    ///        "https://linkedin.com/company/circle"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "medium": {
    ///      "description": "Medium blog URL",
    ///      "examples": [
    ///        "https://medium.com/@circle"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "reddit": {
    ///      "description": "Reddit community URL",
    ///      "examples": [
    ///        "https://reddit.com/r/circle"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "telegram": {
    ///      "description": "Telegram group URL",
    ///      "examples": [
    ///        "https://t.me/circle"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "tiktok": {
    ///      "description": "TikTok handle",
    ///      "examples": [
    ///        "@circle"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "twitter": {
    ///      "description": "Twitter handle or URL",
    ///      "examples": [
    ///        "@circle"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "website": {
    ///      "description": "Official website URL",
    ///      "examples": [
    ///        "https://www.circle.com"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "youtube": {
    ///      "description": "YouTube channel URL",
    ///      "examples": [
    ///        "https://youtube.com/@circle"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct TokenSocialMedias {
        ///Bitbucket repository URL
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub bitbucket: ::std::option::Option<::std::string::String>,
        ///Discord server URL
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub discord: ::std::option::Option<::std::string::String>,
        ///Facebook page URL
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub facebook: ::std::option::Option<::std::string::String>,
        ///GitHub repository URL
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub github: ::std::option::Option<::std::string::String>,
        ///Instagram handle
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub instagram: ::std::option::Option<::std::string::String>,
        ///LinkedIn page URL
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub linkedin: ::std::option::Option<::std::string::String>,
        ///Medium blog URL
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub medium: ::std::option::Option<::std::string::String>,
        ///Reddit community URL
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub reddit: ::std::option::Option<::std::string::String>,
        ///Telegram group URL
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub telegram: ::std::option::Option<::std::string::String>,
        ///TikTok handle
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub tiktok: ::std::option::Option<::std::string::String>,
        ///Twitter handle or URL
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub twitter: ::std::option::Option<::std::string::String>,
        ///Official website URL
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub website: ::std::option::Option<::std::string::String>,
        ///YouTube channel URL
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub youtube: ::std::option::Option<::std::string::String>,
    }
    impl ::std::convert::From<&TokenSocialMedias> for TokenSocialMedias {
        fn from(value: &TokenSocialMedias) -> Self {
            value.clone()
        }
    }
    impl ::std::default::Default for TokenSocialMedias {
        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 TokenSocialMedias {
        pub fn builder() -> builder::TokenSocialMedias {
            Default::default()
        }
    }
    ///Token statistics with nested time period data
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Token statistics with nested time period data",
    ///  "type": "object",
    ///  "required": [
    ///    "address",
    ///    "periods"
    ///  ],
    ///  "properties": {
    ///    "address": {
    ///      "description": "Token contract address",
    ///      "examples": [
    ///        "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "periods": {
    ///      "description": "Trade statistics grouped by time period (1m, 5m, 15m, 30m, 1h, 4h, 6h, 24h).\nEach period contains full OHLCV data, trade counts, and previous-period comparisons.\nSee `TokenTradeStatPeriod` schema for all fields.",
    ///      "examples": [
    ///        {
    ///          "6h": {
    ///            "buyVolumeInUsd": "12000.00",
    ///            "buyers": "120",
    ///            "buys": "420",
    ///            "closeInUsd": "0.15600000",
    ///            "currentLiquidityInUsd": "250000.00",
    ///            "highInUsd": "0.15900000",
    ///            "lowInUsd": "0.15100000",
    ///            "openInUsd": "0.15200000",
    ///            "priceChangeRatioInUsd": "0.02631579",
    ///            "sellVolumeInUsd": "9800.00",
    ///            "sellers": "95",
    ///            "sells": "360",
    ///            "totalVolumeInUsd": "21800.00",
    ///            "traders": "215",
    ///            "trades": "780"
    ///          }
    ///        }
    ///      ],
    ///      "type": "object",
    ///      "additionalProperties": {
    ///        "$ref": "#/components/schemas/TokenTradeStatPeriod"
    ///      }
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct TokenStats {
        ///Token contract address
        pub address: ::std::string::String,
        /**Trade statistics grouped by time period (1m, 5m, 15m, 30m, 1h, 4h, 6h, 24h).
Each period contains full OHLCV data, trade counts, and previous-period comparisons.
See `TokenTradeStatPeriod` schema for all fields.*/
        pub periods: ::std::collections::HashMap<
            ::std::string::String,
            TokenTradeStatPeriod,
        >,
    }
    impl ::std::convert::From<&TokenStats> for TokenStats {
        fn from(value: &TokenStats) -> Self {
            value.clone()
        }
    }
    impl TokenStats {
        pub fn builder() -> builder::TokenStats {
            Default::default()
        }
    }
    ///Single time window trade statistics period
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Single time window trade statistics period",
    ///  "type": "object",
    ///  "properties": {
    ///    "averagePriceInNative": {
    ///      "description": "Average price in native token",
    ///      "examples": [
    ///        "0.00005100"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "averagePriceInUsd": {
    ///      "description": "Average price in USD",
    ///      "examples": [
    ///        "0.15300000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "buySellRatio": {
    ///      "description": "Buy to sell ratio",
    ///      "examples": [
    ///        "1.5510"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "buyVolume": {
    ///      "description": "Buy volume in token amount",
    ///      "examples": [
    ///        "15000000.12345678"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "buyVolumeInNative": {
    ///      "description": "Buy volume in native token",
    ///      "examples": [
    ///        "750.50"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "buyVolumeInUsd": {
    ///      "description": "Buy volume in USD",
    ///      "examples": [
    ///        "45000.00"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "buyers": {
    ///      "description": "Number of unique buyers",
    ///      "examples": [
    ///        "320"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "buys": {
    ///      "description": "Number of buy trades",
    ///      "examples": [
    ///        "1520"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "closeInNative": {
    ///      "description": "Closing price in native token",
    ///      "examples": [
    ///        "0.00005200"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "closeInUsd": {
    ///      "description": "Closing price in USD",
    ///      "examples": [
    ///        "0.15600000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "currentLiquidityInUsd": {
    ///      "description": "Current liquidity in USD",
    ///      "examples": [
    ///        "250000.00"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "dappProgramCount": {
    ///      "description": "Number of DEX programs",
    ///      "examples": [
    ///        "8"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "highInNative": {
    ///      "description": "Highest price in native token",
    ///      "examples": [
    ///        "0.00005300"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "highInUsd": {
    ///      "description": "Highest price in USD",
    ///      "examples": [
    ///        "0.15900000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "liquidityChangeRatio": {
    ///      "description": "Liquidity change ratio vs previous period",
    ///      "examples": [
    ///        "0.0417"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "lowInNative": {
    ///      "description": "Lowest price in native token",
    ///      "examples": [
    ///        "0.00005000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "lowInUsd": {
    ///      "description": "Lowest price in USD",
    ///      "examples": [
    ///        "0.15000000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "openInNative": {
    ///      "description": "Opening price in native token",
    ///      "examples": [
    ///        "0.00005000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "openInUsd": {
    ///      "description": "Opening price in USD",
    ///      "examples": [
    ///        "0.15000000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "poolCount": {
    ///      "description": "Number of liquidity pools",
    ///      "examples": [
    ///        "12"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "prevBuyVolume": {
    ///      "description": "Previous period buy volume in token amount",
    ///      "examples": [
    ///        "14000000.00"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "prevBuyVolumeInNative": {
    ///      "description": "Previous period buy volume in native token",
    ///      "examples": [
    ///        "700.00"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "prevBuyVolumeInUsd": {
    ///      "description": "Previous period buy volume in USD",
    ///      "examples": [
    ///        "42000.00"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "prevBuyers": {
    ///      "description": "Previous period unique buyer count",
    ///      "examples": [
    ///        "300"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "prevBuys": {
    ///      "description": "Previous period buy count",
    ///      "examples": [
    ///        "1400"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "prevCloseInNative": {
    ///      "description": "Previous period closing price in native token",
    ///      "examples": [
    ///        "0.00005100"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "prevCloseInUsd": {
    ///      "description": "Previous period closing price in USD",
    ///      "examples": [
    ///        "0.15100000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "prevDappProgramCount": {
    ///      "description": "Previous period DEX program count",
    ///      "examples": [
    ///        "7"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "prevHighInNative": {
    ///      "description": "Previous period highest price in native token",
    ///      "examples": [
    ///        "0.00005100"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "prevHighInUsd": {
    ///      "description": "Previous period highest price in USD",
    ///      "examples": [
    ///        "0.15200000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "prevLiquidityInUsd": {
    ///      "description": "Previous period liquidity in USD",
    ///      "examples": [
    ///        "240000.00"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "prevLowInNative": {
    ///      "description": "Previous period lowest price in native token",
    ///      "examples": [
    ///        "0.00004800"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "prevLowInUsd": {
    ///      "description": "Previous period lowest price in USD",
    ///      "examples": [
    ///        "0.14500000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "prevOpenInNative": {
    ///      "description": "Previous period opening price in native token",
    ///      "examples": [
    ///        "0.00004900"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "prevOpenInUsd": {
    ///      "description": "Previous period opening price in USD",
    ///      "examples": [
    ///        "0.14800000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "prevPoolCount": {
    ///      "description": "Previous period pool count",
    ///      "examples": [
    ///        "10"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "prevSellVolume": {
    ///      "description": "Previous period sell volume in token amount",
    ///      "examples": [
    ///        "11000000.00"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "prevSellVolumeInNative": {
    ///      "description": "Previous period sell volume in native token",
    ///      "examples": [
    ///        "550.00"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "prevSellVolumeInUsd": {
    ///      "description": "Previous period sell volume in USD",
    ///      "examples": [
    ///        "33000.00"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "prevSellers": {
    ///      "description": "Previous period unique seller count",
    ///      "examples": [
    ///        "200"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "prevSells": {
    ///      "description": "Previous period sell count",
    ///      "examples": [
    ///        "900"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "prevTrades": {
    ///      "description": "Previous period total trade count",
    ///      "examples": [
    ///        "2300"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "priceChangeRatioInUsd": {
    ///      "description": "Price change ratio in USD",
    ///      "examples": [
    ///        "0.04000000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "sellVolume": {
    ///      "description": "Sell volume in token amount",
    ///      "examples": [
    ///        "12000000.98765432"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "sellVolumeInNative": {
    ///      "description": "Sell volume in native token",
    ///      "examples": [
    ///        "600.40"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "sellVolumeInUsd": {
    ///      "description": "Sell volume in USD",
    ///      "examples": [
    ///        "36000.00"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "sellers": {
    ///      "description": "Number of unique sellers",
    ///      "examples": [
    ///        "210"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "sells": {
    ///      "description": "Number of sell trades",
    ///      "examples": [
    ///        "980"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "totalVolumeInNative": {
    ///      "description": "Total trading volume in native token",
    ///      "examples": [
    ///        "1350.90"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "totalVolumeInUsd": {
    ///      "description": "Total trading volume in USD",
    ///      "examples": [
    ///        "81000.00"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "traders": {
    ///      "description": "Number of unique traders",
    ///      "examples": [
    ///        "530"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "trades": {
    ///      "description": "Total number of trades",
    ///      "examples": [
    ///        "2500"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "updatedAt": {
    ///      "description": "Last updated timestamp",
    ///      "examples": [
    ///        "2026-02-09T08:05:12.345Z"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "volumeChangeRatio": {
    ///      "description": "Volume change ratio vs previous period",
    ///      "examples": [
    ///        "0.25"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct TokenTradeStatPeriod {
        ///Average price in native token
        #[serde(
            rename = "averagePriceInNative",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub average_price_in_native: ::std::option::Option<::std::string::String>,
        ///Average price in USD
        #[serde(
            rename = "averagePriceInUsd",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub average_price_in_usd: ::std::option::Option<::std::string::String>,
        ///Buy to sell ratio
        #[serde(
            rename = "buySellRatio",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub buy_sell_ratio: ::std::option::Option<::std::string::String>,
        ///Buy volume in token amount
        #[serde(
            rename = "buyVolume",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub buy_volume: ::std::option::Option<::std::string::String>,
        ///Buy volume in native token
        #[serde(
            rename = "buyVolumeInNative",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub buy_volume_in_native: ::std::option::Option<::std::string::String>,
        ///Buy volume in USD
        #[serde(
            rename = "buyVolumeInUsd",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub buy_volume_in_usd: ::std::option::Option<::std::string::String>,
        ///Number of unique buyers
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub buyers: ::std::option::Option<::std::string::String>,
        ///Number of buy trades
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub buys: ::std::option::Option<::std::string::String>,
        ///Closing price in native token
        #[serde(
            rename = "closeInNative",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub close_in_native: ::std::option::Option<::std::string::String>,
        ///Closing price in USD
        #[serde(
            rename = "closeInUsd",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub close_in_usd: ::std::option::Option<::std::string::String>,
        ///Current liquidity in USD
        #[serde(
            rename = "currentLiquidityInUsd",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub current_liquidity_in_usd: ::std::option::Option<::std::string::String>,
        ///Number of DEX programs
        #[serde(
            rename = "dappProgramCount",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub dapp_program_count: ::std::option::Option<::std::string::String>,
        ///Highest price in native token
        #[serde(
            rename = "highInNative",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub high_in_native: ::std::option::Option<::std::string::String>,
        ///Highest price in USD
        #[serde(
            rename = "highInUsd",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub high_in_usd: ::std::option::Option<::std::string::String>,
        ///Liquidity change ratio vs previous period
        #[serde(
            rename = "liquidityChangeRatio",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub liquidity_change_ratio: ::std::option::Option<::std::string::String>,
        ///Lowest price in native token
        #[serde(
            rename = "lowInNative",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub low_in_native: ::std::option::Option<::std::string::String>,
        ///Lowest price in USD
        #[serde(
            rename = "lowInUsd",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub low_in_usd: ::std::option::Option<::std::string::String>,
        ///Opening price in native token
        #[serde(
            rename = "openInNative",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub open_in_native: ::std::option::Option<::std::string::String>,
        ///Opening price in USD
        #[serde(
            rename = "openInUsd",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub open_in_usd: ::std::option::Option<::std::string::String>,
        ///Number of liquidity pools
        #[serde(
            rename = "poolCount",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub pool_count: ::std::option::Option<::std::string::String>,
        ///Previous period buy volume in token amount
        #[serde(
            rename = "prevBuyVolume",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub prev_buy_volume: ::std::option::Option<::std::string::String>,
        ///Previous period buy volume in native token
        #[serde(
            rename = "prevBuyVolumeInNative",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub prev_buy_volume_in_native: ::std::option::Option<::std::string::String>,
        ///Previous period buy volume in USD
        #[serde(
            rename = "prevBuyVolumeInUsd",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub prev_buy_volume_in_usd: ::std::option::Option<::std::string::String>,
        ///Previous period unique buyer count
        #[serde(
            rename = "prevBuyers",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub prev_buyers: ::std::option::Option<::std::string::String>,
        ///Previous period buy count
        #[serde(
            rename = "prevBuys",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub prev_buys: ::std::option::Option<::std::string::String>,
        ///Previous period closing price in native token
        #[serde(
            rename = "prevCloseInNative",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub prev_close_in_native: ::std::option::Option<::std::string::String>,
        ///Previous period closing price in USD
        #[serde(
            rename = "prevCloseInUsd",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub prev_close_in_usd: ::std::option::Option<::std::string::String>,
        ///Previous period DEX program count
        #[serde(
            rename = "prevDappProgramCount",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub prev_dapp_program_count: ::std::option::Option<::std::string::String>,
        ///Previous period highest price in native token
        #[serde(
            rename = "prevHighInNative",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub prev_high_in_native: ::std::option::Option<::std::string::String>,
        ///Previous period highest price in USD
        #[serde(
            rename = "prevHighInUsd",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub prev_high_in_usd: ::std::option::Option<::std::string::String>,
        ///Previous period liquidity in USD
        #[serde(
            rename = "prevLiquidityInUsd",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub prev_liquidity_in_usd: ::std::option::Option<::std::string::String>,
        ///Previous period lowest price in native token
        #[serde(
            rename = "prevLowInNative",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub prev_low_in_native: ::std::option::Option<::std::string::String>,
        ///Previous period lowest price in USD
        #[serde(
            rename = "prevLowInUsd",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub prev_low_in_usd: ::std::option::Option<::std::string::String>,
        ///Previous period opening price in native token
        #[serde(
            rename = "prevOpenInNative",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub prev_open_in_native: ::std::option::Option<::std::string::String>,
        ///Previous period opening price in USD
        #[serde(
            rename = "prevOpenInUsd",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub prev_open_in_usd: ::std::option::Option<::std::string::String>,
        ///Previous period pool count
        #[serde(
            rename = "prevPoolCount",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub prev_pool_count: ::std::option::Option<::std::string::String>,
        ///Previous period sell volume in token amount
        #[serde(
            rename = "prevSellVolume",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub prev_sell_volume: ::std::option::Option<::std::string::String>,
        ///Previous period sell volume in native token
        #[serde(
            rename = "prevSellVolumeInNative",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub prev_sell_volume_in_native: ::std::option::Option<::std::string::String>,
        ///Previous period sell volume in USD
        #[serde(
            rename = "prevSellVolumeInUsd",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub prev_sell_volume_in_usd: ::std::option::Option<::std::string::String>,
        ///Previous period unique seller count
        #[serde(
            rename = "prevSellers",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub prev_sellers: ::std::option::Option<::std::string::String>,
        ///Previous period sell count
        #[serde(
            rename = "prevSells",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub prev_sells: ::std::option::Option<::std::string::String>,
        ///Previous period total trade count
        #[serde(
            rename = "prevTrades",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub prev_trades: ::std::option::Option<::std::string::String>,
        ///Price change ratio in USD
        #[serde(
            rename = "priceChangeRatioInUsd",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub price_change_ratio_in_usd: ::std::option::Option<::std::string::String>,
        ///Sell volume in token amount
        #[serde(
            rename = "sellVolume",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub sell_volume: ::std::option::Option<::std::string::String>,
        ///Sell volume in native token
        #[serde(
            rename = "sellVolumeInNative",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub sell_volume_in_native: ::std::option::Option<::std::string::String>,
        ///Sell volume in USD
        #[serde(
            rename = "sellVolumeInUsd",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub sell_volume_in_usd: ::std::option::Option<::std::string::String>,
        ///Number of unique sellers
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub sellers: ::std::option::Option<::std::string::String>,
        ///Number of sell trades
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub sells: ::std::option::Option<::std::string::String>,
        ///Total trading volume in native token
        #[serde(
            rename = "totalVolumeInNative",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub total_volume_in_native: ::std::option::Option<::std::string::String>,
        ///Total trading volume in USD
        #[serde(
            rename = "totalVolumeInUsd",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub total_volume_in_usd: ::std::option::Option<::std::string::String>,
        ///Number of unique traders
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub traders: ::std::option::Option<::std::string::String>,
        ///Total number of trades
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub trades: ::std::option::Option<::std::string::String>,
        ///Last updated timestamp
        #[serde(
            rename = "updatedAt",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub updated_at: ::std::option::Option<::std::string::String>,
        ///Volume change ratio vs previous period
        #[serde(
            rename = "volumeChangeRatio",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub volume_change_ratio: ::std::option::Option<::std::string::String>,
    }
    impl ::std::convert::From<&TokenTradeStatPeriod> for TokenTradeStatPeriod {
        fn from(value: &TokenTradeStatPeriod) -> Self {
            value.clone()
        }
    }
    impl ::std::default::Default for TokenTradeStatPeriod {
        fn default() -> Self {
            Self {
                average_price_in_native: Default::default(),
                average_price_in_usd: Default::default(),
                buy_sell_ratio: Default::default(),
                buy_volume: Default::default(),
                buy_volume_in_native: Default::default(),
                buy_volume_in_usd: Default::default(),
                buyers: Default::default(),
                buys: Default::default(),
                close_in_native: Default::default(),
                close_in_usd: Default::default(),
                current_liquidity_in_usd: Default::default(),
                dapp_program_count: Default::default(),
                high_in_native: Default::default(),
                high_in_usd: Default::default(),
                liquidity_change_ratio: Default::default(),
                low_in_native: Default::default(),
                low_in_usd: Default::default(),
                open_in_native: Default::default(),
                open_in_usd: Default::default(),
                pool_count: Default::default(),
                prev_buy_volume: Default::default(),
                prev_buy_volume_in_native: Default::default(),
                prev_buy_volume_in_usd: Default::default(),
                prev_buyers: Default::default(),
                prev_buys: Default::default(),
                prev_close_in_native: Default::default(),
                prev_close_in_usd: Default::default(),
                prev_dapp_program_count: Default::default(),
                prev_high_in_native: Default::default(),
                prev_high_in_usd: Default::default(),
                prev_liquidity_in_usd: Default::default(),
                prev_low_in_native: Default::default(),
                prev_low_in_usd: Default::default(),
                prev_open_in_native: Default::default(),
                prev_open_in_usd: Default::default(),
                prev_pool_count: Default::default(),
                prev_sell_volume: Default::default(),
                prev_sell_volume_in_native: Default::default(),
                prev_sell_volume_in_usd: Default::default(),
                prev_sellers: Default::default(),
                prev_sells: Default::default(),
                prev_trades: Default::default(),
                price_change_ratio_in_usd: Default::default(),
                sell_volume: Default::default(),
                sell_volume_in_native: Default::default(),
                sell_volume_in_usd: Default::default(),
                sellers: Default::default(),
                sells: Default::default(),
                total_volume_in_native: Default::default(),
                total_volume_in_usd: Default::default(),
                traders: Default::default(),
                trades: Default::default(),
                updated_at: Default::default(),
                volume_change_ratio: Default::default(),
            }
        }
    }
    impl TokenTradeStatPeriod {
        pub fn builder() -> builder::TokenTradeStatPeriod {
            Default::default()
        }
    }
    ///Token trader info — mirrors TS `TokenTraderDTO`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Token trader info — mirrors TS `TokenTraderDTO`",
    ///  "type": "object",
    ///  "required": [
    ///    "address"
    ///  ],
    ///  "properties": {
    ///    "address": {
    ///      "description": "Wallet address",
    ///      "examples": [
    ///        "MJKqp326RZCHnAAbew9MDdui3iCKWco7fsK9sVuZTX2"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "blockTimestamp": {
    ///      "description": "Block timestamp (sniper)",
    ///      "examples": [
    ///        "2025-01-15T10:30:00Z"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "onchainCreatedAt": {
    ///      "description": "Onchain account creation time (fresh/dev)",
    ///      "examples": [
    ///        "2025-01-15T10:30:00Z"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "percentileRankTradeAmountInUsd": {
    ///      "description": "Percentile rank of trade amount in USD (pro/insider)",
    ///      "examples": [
    ///        "0.98"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "percentileRankTradeCount": {
    ///      "description": "Percentile rank of trade count (pro)",
    ///      "examples": [
    ///        95
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "rankTradeAmountInUsd": {
    ///      "description": "Rank trade amount in USD (insider)",
    ///      "examples": [
    ///        "0.95"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "tradeAmountInNative": {
    ///      "description": "Trade amount in native token (pro/insider)",
    ///      "examples": [
    ///        "1500.50"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "tradeAmountInUsd": {
    ///      "description": "Trade amount in USD (pro/insider)",
    ///      "examples": [
    ///        "45000.00"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "tradeCount": {
    ///      "description": "Trade count (pro/insider)",
    ///      "examples": [
    ///        42
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "transactionSignature": {
    ///      "description": "Transaction signature (sandwish/bundle/sniper)",
    ///      "examples": [
    ///        "5dJ1BxPiFT7w7aBdkxNy2jopGZnZoLwRwS8e9GkEXrVz..."
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct TokenTrader {
        ///Wallet address
        pub address: ::std::string::String,
        ///Block timestamp (sniper)
        #[serde(
            rename = "blockTimestamp",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub block_timestamp: ::std::option::Option<::std::string::String>,
        ///Onchain account creation time (fresh/dev)
        #[serde(
            rename = "onchainCreatedAt",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub onchain_created_at: ::std::option::Option<::std::string::String>,
        ///Percentile rank of trade amount in USD (pro/insider)
        #[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,
        >,
        ///Percentile rank of trade count (pro)
        #[serde(
            rename = "percentileRankTradeCount",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub percentile_rank_trade_count: ::std::option::Option<i64>,
        ///Rank trade amount in USD (insider)
        #[serde(
            rename = "rankTradeAmountInUsd",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub rank_trade_amount_in_usd: ::std::option::Option<::std::string::String>,
        ///Trade amount in native token (pro/insider)
        #[serde(
            rename = "tradeAmountInNative",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub trade_amount_in_native: ::std::option::Option<::std::string::String>,
        ///Trade amount in USD (pro/insider)
        #[serde(
            rename = "tradeAmountInUsd",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub trade_amount_in_usd: ::std::option::Option<::std::string::String>,
        ///Trade count (pro/insider)
        #[serde(
            rename = "tradeCount",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub trade_count: ::std::option::Option<i64>,
        ///Transaction signature (sandwish/bundle/sniper)
        #[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()
        }
    }
    ///Token trader tag
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Token trader tag",
    ///  "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()
        }
    }
    ///Token transfer
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Token transfer",
    ///  "type": "object",
    ///  "required": [
    ///    "amount",
    ///    "blockTimestamp",
    ///    "fromAddress",
    ///    "id",
    ///    "status",
    ///    "toAddress",
    ///    "tokenAddress",
    ///    "transactionSignature",
    ///    "type"
    ///  ],
    ///  "properties": {
    ///    "amount": {
    ///      "description": "Transfer amount in token units",
    ///      "examples": [
    ///        "1738227.69"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "amountInUsd": {
    ///      "description": "Transfer amount in USD",
    ///      "examples": [
    ///        "4.07"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "blockTimestamp": {
    ///      "description": "Block timestamp (milliseconds)",
    ///      "examples": [
    ///        1710417600000
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "fromAddress": {
    ///      "description": "Sender address",
    ///      "examples": [
    ///        "3xad3gVnkBLA48PwPApHTu7zSWBV3x6dUfNnBSmMNvn3"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "id": {
    ///      "description": "Transfer record identifier",
    ///      "examples": [
    ///        "transfer-1"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "status": {
    ///      "description": "Transfer status: unknown / succeeded / failed",
    ///      "examples": [
    ///        "succeeded"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "toAddress": {
    ///      "description": "Receiver address",
    ///      "examples": [
    ///        "FgkE7Kwvt4DAU2MbaZmf8ZwKFUUDXR5ownmuYKsUqkxs"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "tokenAddress": {
    ///      "description": "Token contract address",
    ///      "examples": [
    ///        "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "transactionSignature": {
    ///      "description": "Transaction signature",
    ///      "examples": [
    ///        "3hmmomhUcmLMw2ZCqKg5MBfK8b7RBNrBpqvE2Wv7u5V6PCMLh4s7dVfA83NbzNFAgTzVvZuMURoKEviwR92otRp"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "type": {
    ///      "description": "Transfer type: unknown / in / out",
    ///      "examples": [
    ///        "in"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct TokenTransfer {
        ///Transfer amount in token units
        pub amount: ::std::string::String,
        ///Transfer amount in USD
        #[serde(
            rename = "amountInUsd",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub amount_in_usd: ::std::option::Option<::std::string::String>,
        ///Block timestamp (milliseconds)
        #[serde(rename = "blockTimestamp")]
        pub block_timestamp: i64,
        ///Sender address
        #[serde(rename = "fromAddress")]
        pub from_address: ::std::string::String,
        ///Transfer record identifier
        pub id: ::std::string::String,
        ///Transfer status: unknown / succeeded / failed
        pub status: ::std::string::String,
        ///Receiver address
        #[serde(rename = "toAddress")]
        pub to_address: ::std::string::String,
        ///Token contract address
        #[serde(rename = "tokenAddress")]
        pub token_address: ::std::string::String,
        ///Transaction signature
        #[serde(rename = "transactionSignature")]
        pub transaction_signature: ::std::string::String,
        ///Transfer type: unknown / in / out
        #[serde(rename = "type")]
        pub type_: ::std::string::String,
    }
    impl ::std::convert::From<&TokenTransfer> for TokenTransfer {
        fn from(value: &TokenTransfer) -> Self {
            value.clone()
        }
    }
    impl TokenTransfer {
        pub fn builder() -> builder::TokenTransfer {
            Default::default()
        }
    }
    ///Token transfer total count
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Token transfer total count",
    ///  "type": "object",
    ///  "required": [
    ///    "total"
    ///  ],
    ///  "properties": {
    ///    "total": {
    ///      "description": "Total number of transfers",
    ///      "examples": [
    ///        123456
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct TokenTransferTotal {
        ///Total number of transfers
        pub total: i64,
    }
    impl ::std::convert::From<&TokenTransferTotal> for TokenTransferTotal {
        fn from(value: &TokenTransferTotal) -> Self {
            value.clone()
        }
    }
    impl TokenTransferTotal {
        pub fn builder() -> builder::TokenTransferTotal {
            Default::default()
        }
    }
    ///Top trader statistics
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Top trader statistics",
    ///  "type": "object",
    ///  "required": [
    ///    "buyAmount",
    ///    "buyAmountInNative",
    ///    "buyAmountInUsd",
    ///    "buyCount",
    ///    "sellAmount",
    ///    "sellAmountInNative",
    ///    "sellAmountInUsd",
    ///    "sellCount",
    ///    "tokenAddress",
    ///    "tradeAmount",
    ///    "tradeCount",
    ///    "walletAddress"
    ///  ],
    ///  "properties": {
    ///    "buyAmount": {
    ///      "description": "Total buy amount in token units",
    ///      "examples": [
    ///        "600000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "buyAmountInNative": {
    ///      "description": "Total buy amount in native token",
    ///      "examples": [
    ///        "100.5"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "buyAmountInUsd": {
    ///      "description": "Total buy amount in USD",
    ///      "examples": [
    ///        "12000.50"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "buyCount": {
    ///      "description": "Number of buy trades",
    ///      "examples": [
    ///        60
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "sellAmount": {
    ///      "description": "Total sell amount in token units",
    ///      "examples": [
    ///        "400000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "sellAmountInNative": {
    ///      "description": "Total sell amount in native token",
    ///      "examples": [
    ///        "66.8"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "sellAmountInUsd": {
    ///      "description": "Total sell amount in USD",
    ///      "examples": [
    ///        "8000.30"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "sellCount": {
    ///      "description": "Number of sell trades",
    ///      "examples": [
    ///        40
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "tokenAddress": {
    ///      "description": "Token contract address",
    ///      "examples": [
    ///        "6p6xgHyF7AeE6TZkSmFsko444wqoP15icUSqi2jfGiPN"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "tradeAmount": {
    ///      "description": "Total trade amount in token units",
    ///      "examples": [
    ///        "1000000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "tradeCount": {
    ///      "description": "Total number of trades",
    ///      "examples": [
    ///        100
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "walletAddress": {
    ///      "description": "Trader wallet address",
    ///      "examples": [
    ///        "3xd4LGVWtYXLBspR6X5JWbW49NXmEehfPtX6Kqx98b4w"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct TopTrader {
        ///Total buy amount in token units
        #[serde(rename = "buyAmount")]
        pub buy_amount: ::std::string::String,
        ///Total buy amount in native token
        #[serde(rename = "buyAmountInNative")]
        pub buy_amount_in_native: ::std::string::String,
        ///Total buy amount in USD
        #[serde(rename = "buyAmountInUsd")]
        pub buy_amount_in_usd: ::std::string::String,
        ///Number of buy trades
        #[serde(rename = "buyCount")]
        pub buy_count: i64,
        ///Total sell amount in token units
        #[serde(rename = "sellAmount")]
        pub sell_amount: ::std::string::String,
        ///Total sell amount in native token
        #[serde(rename = "sellAmountInNative")]
        pub sell_amount_in_native: ::std::string::String,
        ///Total sell amount in USD
        #[serde(rename = "sellAmountInUsd")]
        pub sell_amount_in_usd: ::std::string::String,
        ///Number of sell trades
        #[serde(rename = "sellCount")]
        pub sell_count: i64,
        ///Token contract address
        #[serde(rename = "tokenAddress")]
        pub token_address: ::std::string::String,
        ///Total trade amount in token units
        #[serde(rename = "tradeAmount")]
        pub trade_amount: ::std::string::String,
        ///Total number of trades
        #[serde(rename = "tradeCount")]
        pub trade_count: i64,
        ///Trader wallet address
        #[serde(rename = "walletAddress")]
        pub wallet_address: ::std::string::String,
    }
    impl ::std::convert::From<&TopTrader> for TopTrader {
        fn from(value: &TopTrader) -> Self {
            value.clone()
        }
    }
    impl TopTrader {
        pub fn builder() -> builder::TopTrader {
            Default::default()
        }
    }
    ///Sort field for top traders query
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Sort field for top traders query",
    ///  "type": "string",
    ///  "enum": [
    ///    "tradeAmount",
    ///    "tradeCount"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum TopTraderSortBy {
        #[serde(rename = "tradeAmount")]
        TradeAmount,
        #[serde(rename = "tradeCount")]
        TradeCount,
    }
    impl ::std::convert::From<&Self> for TopTraderSortBy {
        fn from(value: &TopTraderSortBy) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for TopTraderSortBy {
        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 TopTraderSortBy {
        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 TopTraderSortBy {
        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 TopTraderSortBy {
        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 TopTraderSortBy {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    ///Trade detail
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Trade detail",
    ///  "type": "object",
    ///  "required": [
    ///    "accountOwnerAddress",
    ///    "blockHeight",
    ///    "blockTimestamp",
    ///    "chain",
    ///    "poolAddress",
    ///    "sideTokenAddress",
    ///    "sideTokenAmount",
    ///    "sideTokenAmountInNative",
    ///    "sideTokenAmountInUsd",
    ///    "sideTokenName",
    ///    "sideTokenPriceInNative",
    ///    "sideTokenPriceInUsd",
    ///    "sideTokenSymbol",
    ///    "status",
    ///    "tokenAddress",
    ///    "tokenAmount",
    ///    "tokenAmountInNative",
    ///    "tokenAmountInUsd",
    ///    "tokenName",
    ///    "tokenPriceInNative",
    ///    "tokenPriceInUsd",
    ///    "tokenSymbol",
    ///    "transactionSignature",
    ///    "type"
    ///  ],
    ///  "properties": {
    ///    "accountOwnerAddress": {
    ///      "description": "Account owner address (trader wallet)",
    ///      "examples": [
    ///        "3xd4LGVWtYXLBspR6X5JWbW49NXmEehfPtX6Kqx98b4w"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "blockHeight": {
    ///      "description": "Block height",
    ///      "examples": [
    ///        332417228
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "blockTimestamp": {
    ///      "description": "Block timestamp (milliseconds)",
    ///      "examples": [
    ///        1717334400000
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "chain": {
    ///      "description": "Chain identifier",
    ///      "examples": [
    ///        "sol"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "dexImage": {
    ///      "description": "DEX image",
    ///      "examples": [
    ///        "https://example.com/dex.png"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "dexProgramAddress": {
    ///      "description": "DEX program address",
    ///      "examples": [
    ///        "whirLbMiicVdio4qvUfM5KAg6Ct8VwpYzGff3uctyCc"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "dexProtocolFamily": {
    ///      "description": "DEX protocol family",
    ///      "examples": [
    ///        "OrcaWhirpool"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "gasFee": {
    ///      "description": "Gas fee (raw: lamports for SOL, Gwei for BSC)",
    ///      "examples": [
    ///        5000
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "gasFeeInNative": {
    ///      "description": "Gas fee in native currency (SOL / BNB / ETH)",
    ///      "examples": [
    ///        "0.000073"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "gasFeeInUsd": {
    ///      "description": "Gas fee in USD",
    ///      "examples": [
    ///        "0.011"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "historyBoughtAmount": {
    ///      "description": "Cumulative token quantity bought by this wallet (up to and including this trade).\nMatches GMGN `history_bought_amount`.",
    ///      "type": "string"
    ///    },
    ///    "historySoldAmount": {
    ///      "description": "Cumulative token quantity sold by this wallet (up to and including this trade).\nMatches GMGN `history_sold_amount`.",
    ///      "type": "string"
    ///    },
    ///    "isOpenOrClose": {
    ///      "description": "Position lifecycle: 0=normal, 1=open_position, 2=close_position\nMatches GMGN `is_open_or_close` field.",
    ///      "type": "integer",
    ///      "format": "int32"
    ///    },
    ///    "makerEventTags": {
    ///      "description": "Trade behaviour tags for this event (e.g. \"open_position\", \"dip_buy\",\n\"take_profit\", \"stop_loss\", \"close_position\", \"accumulate\",\n\"transfer_in\", \"transfer_out\").\nMatches GMGN `maker_token_tags` on the activity level.",
    ///      "type": "array",
    ///      "items": {
    ///        "type": "string"
    ///      }
    ///    },
    ///    "marketCapInUsd": {
    ///      "description": "Market cap in USD at trade time",
    ///      "examples": [
    ///        "1500000.00"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "poolAddress": {
    ///      "description": "Pool address",
    ///      "examples": [
    ///        "58oQChx4yWmvKdwLLZzBi4ChoCc2fqCUWBkwMihLYQo2"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "postBalance": {
    ///      "description": "Token balance after this trade (token quantity).\nMatches GMGN `balance` in activity feed.",
    ///      "type": "string"
    ///    },
    ///    "realizedProfitInUsd": {
    ///      "description": "Realized PnL for this specific trade in USD (non-zero only on Sell events).\nMatches GMGN `realized_profit`.",
    ///      "type": "string"
    ///    },
    ///    "sideTokenAddress": {
    ///      "description": "Side token address",
    ///      "examples": [
    ///        "So11111111111111111111111111111111111111112"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "sideTokenAmount": {
    ///      "description": "Side token amount",
    ///      "examples": [
    ///        "1"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "sideTokenAmountInNative": {
    ///      "description": "Side token amount in native currency",
    ///      "examples": [
    ///        "150"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "sideTokenAmountInUsd": {
    ///      "description": "Side token amount in USD",
    ///      "examples": [
    ///        "150"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "sideTokenImageUrl": {
    ///      "description": "Side token image URL",
    ///      "examples": [
    ///        "https://arweave.net/sol.png"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "sideTokenName": {
    ///      "description": "Side token name",
    ///      "examples": [
    ///        "Wrapped SOL"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "sideTokenPriceInNative": {
    ///      "description": "Side token price in native currency",
    ///      "examples": [
    ///        "1"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "sideTokenPriceInUsd": {
    ///      "description": "Side token price in USD",
    ///      "examples": [
    ///        "150"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "sideTokenSymbol": {
    ///      "description": "Side token symbol",
    ///      "examples": [
    ///        "SOL"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "status": {
    ///      "description": "Transaction status",
    ///      "examples": [
    ///        "SUCCEEDED"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "tokenAddress": {
    ///      "description": "Token address",
    ///      "examples": [
    ///        "6p6xgHyF7AeE6TZkSmFsko444wqoP15icUSqi2jfGiPN"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "tokenAmount": {
    ///      "description": "Token amount",
    ///      "examples": [
    ///        "1000000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "tokenAmountInNative": {
    ///      "description": "Token amount in native currency",
    ///      "examples": [
    ///        "100"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "tokenAmountInUsd": {
    ///      "description": "Token amount in USD",
    ///      "examples": [
    ///        "8800000"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "tokenImageUrl": {
    ///      "description": "Token image URL",
    ///      "examples": [
    ///        "https://arweave.net/token.png"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "tokenName": {
    ///      "description": "Token name",
    ///      "examples": [
    ///        "TRUMP"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "tokenPriceInNative": {
    ///      "description": "Token price in native currency",
    ///      "examples": [
    ///        "0.0001"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "tokenPriceInUsd": {
    ///      "description": "Token price in USD",
    ///      "examples": [
    ///        "8.80"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "tokenSymbol": {
    ///      "description": "Token symbol",
    ///      "examples": [
    ///        "TRUMP"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "traderTags": {
    ///      "description": "Trader classification tags (e.g. \"kol\", \"smart\", \"sniper\", \"dev\", \"bundle\", \"bluechip\")",
    ///      "type": "array",
    ///      "items": {
    ///        "type": "string"
    ///      }
    ///    },
    ///    "transactionSignature": {
    ///      "description": "Transaction signature",
    ///      "examples": [
    ///        "37XpPt9Ak6JiE1V3sftJDtdUsvR9FVFRqkZmoT3dp4BTD9pgyTWn1XgHH6R7NjuJ4pBMAgj8JvZtxQrf4s6NTC5F"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "type": {
    ///      "description": "Trade type (BUY/SELL)",
    ///      "examples": [
    ///        "BUY"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct TradeDetail {
        ///Account owner address (trader wallet)
        #[serde(rename = "accountOwnerAddress")]
        pub account_owner_address: ::std::string::String,
        ///Block height
        #[serde(rename = "blockHeight")]
        pub block_height: i64,
        ///Block timestamp (milliseconds)
        #[serde(rename = "blockTimestamp")]
        pub block_timestamp: i64,
        ///Chain identifier
        pub chain: ::std::string::String,
        ///DEX image
        #[serde(
            rename = "dexImage",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub dex_image: ::std::option::Option<::std::string::String>,
        ///DEX program address
        #[serde(
            rename = "dexProgramAddress",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub dex_program_address: ::std::option::Option<::std::string::String>,
        ///DEX protocol family
        #[serde(
            rename = "dexProtocolFamily",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub dex_protocol_family: ::std::option::Option<::std::string::String>,
        ///Gas fee (raw: lamports for SOL, Gwei for BSC)
        #[serde(
            rename = "gasFee",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub gas_fee: ::std::option::Option<i64>,
        ///Gas fee in native currency (SOL / BNB / ETH)
        #[serde(
            rename = "gasFeeInNative",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub gas_fee_in_native: ::std::option::Option<::std::string::String>,
        ///Gas fee in USD
        #[serde(
            rename = "gasFeeInUsd",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub gas_fee_in_usd: ::std::option::Option<::std::string::String>,
        /**Cumulative token quantity bought by this wallet (up to and including this trade).
Matches GMGN `history_bought_amount`.*/
        #[serde(
            rename = "historyBoughtAmount",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub history_bought_amount: ::std::option::Option<::std::string::String>,
        /**Cumulative token quantity sold by this wallet (up to and including this trade).
Matches GMGN `history_sold_amount`.*/
        #[serde(
            rename = "historySoldAmount",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub history_sold_amount: ::std::option::Option<::std::string::String>,
        /**Position lifecycle: 0=normal, 1=open_position, 2=close_position
Matches GMGN `is_open_or_close` field.*/
        #[serde(
            rename = "isOpenOrClose",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub is_open_or_close: ::std::option::Option<i32>,
        /**Trade behaviour tags for this event (e.g. "open_position", "dip_buy",
"take_profit", "stop_loss", "close_position", "accumulate",
"transfer_in", "transfer_out").
Matches GMGN `maker_token_tags` on the activity level.*/
        #[serde(
            rename = "makerEventTags",
            default,
            skip_serializing_if = "::std::vec::Vec::is_empty"
        )]
        pub maker_event_tags: ::std::vec::Vec<::std::string::String>,
        ///Market cap in USD at trade time
        #[serde(
            rename = "marketCapInUsd",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub market_cap_in_usd: ::std::option::Option<::std::string::String>,
        ///Pool address
        #[serde(rename = "poolAddress")]
        pub pool_address: ::std::string::String,
        /**Token balance after this trade (token quantity).
Matches GMGN `balance` in activity feed.*/
        #[serde(
            rename = "postBalance",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub post_balance: ::std::option::Option<::std::string::String>,
        /**Realized PnL for this specific trade in USD (non-zero only on Sell events).
Matches GMGN `realized_profit`.*/
        #[serde(
            rename = "realizedProfitInUsd",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub realized_profit_in_usd: ::std::option::Option<::std::string::String>,
        ///Side token address
        #[serde(rename = "sideTokenAddress")]
        pub side_token_address: ::std::string::String,
        ///Side token amount
        #[serde(rename = "sideTokenAmount")]
        pub side_token_amount: ::std::string::String,
        ///Side token amount in native currency
        #[serde(rename = "sideTokenAmountInNative")]
        pub side_token_amount_in_native: ::std::string::String,
        ///Side token amount in USD
        #[serde(rename = "sideTokenAmountInUsd")]
        pub side_token_amount_in_usd: ::std::string::String,
        ///Side token image URL
        #[serde(
            rename = "sideTokenImageUrl",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub side_token_image_url: ::std::option::Option<::std::string::String>,
        ///Side token name
        #[serde(rename = "sideTokenName")]
        pub side_token_name: ::std::string::String,
        ///Side token price in native currency
        #[serde(rename = "sideTokenPriceInNative")]
        pub side_token_price_in_native: ::std::string::String,
        ///Side token price in USD
        #[serde(rename = "sideTokenPriceInUsd")]
        pub side_token_price_in_usd: ::std::string::String,
        ///Side token symbol
        #[serde(rename = "sideTokenSymbol")]
        pub side_token_symbol: ::std::string::String,
        ///Transaction status
        pub status: ::std::string::String,
        ///Token address
        #[serde(rename = "tokenAddress")]
        pub token_address: ::std::string::String,
        ///Token amount
        #[serde(rename = "tokenAmount")]
        pub token_amount: ::std::string::String,
        ///Token amount in native currency
        #[serde(rename = "tokenAmountInNative")]
        pub token_amount_in_native: ::std::string::String,
        ///Token amount in USD
        #[serde(rename = "tokenAmountInUsd")]
        pub token_amount_in_usd: ::std::string::String,
        ///Token image URL
        #[serde(
            rename = "tokenImageUrl",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub token_image_url: ::std::option::Option<::std::string::String>,
        ///Token name
        #[serde(rename = "tokenName")]
        pub token_name: ::std::string::String,
        ///Token price in native currency
        #[serde(rename = "tokenPriceInNative")]
        pub token_price_in_native: ::std::string::String,
        ///Token price in USD
        #[serde(rename = "tokenPriceInUsd")]
        pub token_price_in_usd: ::std::string::String,
        ///Token symbol
        #[serde(rename = "tokenSymbol")]
        pub token_symbol: ::std::string::String,
        ///Trader classification tags (e.g. "kol", "smart", "sniper", "dev", "bundle", "bluechip")
        #[serde(
            rename = "traderTags",
            default,
            skip_serializing_if = "::std::vec::Vec::is_empty"
        )]
        pub trader_tags: ::std::vec::Vec<::std::string::String>,
        ///Transaction signature
        #[serde(rename = "transactionSignature")]
        pub transaction_signature: ::std::string::String,
        ///Trade type (BUY/SELL)
        #[serde(rename = "type")]
        pub type_: ::std::string::String,
    }
    impl ::std::convert::From<&TradeDetail> for TradeDetail {
        fn from(value: &TradeDetail) -> Self {
            value.clone()
        }
    }
    impl TradeDetail {
        pub fn builder() -> builder::TradeDetail {
            Default::default()
        }
    }
    ///Trade type
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Trade type",
    ///  "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()
        }
    }
    ///Trader gainers/losers item — PnL-based ranking
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Trader gainers/losers item — PnL-based ranking",
    ///  "type": "object",
    ///  "required": [
    ///    "address",
    ///    "chain",
    ///    "pnl",
    ///    "tradeCount",
    ///    "volume"
    ///  ],
    ///  "properties": {
    ///    "address": {
    ///      "description": "Trader wallet address",
    ///      "examples": [
    ///        "3xd4LGVWtYXLBspR6X5JWbW49NXmEehfPtX6Kqx98b4w"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "chain": {
    ///      "description": "Blockchain network identifier",
    ///      "examples": [
    ///        "sol"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "pnl": {
    ///      "description": "Profit and loss amount in USD",
    ///      "examples": [
    ///        "12500.50"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "tradeCount": {
    ///      "description": "Total number of trades",
    ///      "examples": [
    ///        "150"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "volume": {
    ///      "description": "Total trading volume in USD",
    ///      "examples": [
    ///        "85000.00"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct TraderGainersLosersItem {
        ///Trader wallet address
        pub address: ::std::string::String,
        ///Blockchain network identifier
        pub chain: ::std::string::String,
        ///Profit and loss amount in USD
        pub pnl: ::std::string::String,
        ///Total number of trades
        #[serde(rename = "tradeCount")]
        pub trade_count: ::std::string::String,
        ///Total trading volume in USD
        pub volume: ::std::string::String,
    }
    impl ::std::convert::From<&TraderGainersLosersItem> for TraderGainersLosersItem {
        fn from(value: &TraderGainersLosersItem) -> Self {
            value.clone()
        }
    }
    impl TraderGainersLosersItem {
        pub fn builder() -> builder::TraderGainersLosersItem {
            Default::default()
        }
    }
    ///Trader PnL resolution period
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Trader PnL resolution period",
    ///  "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()
        }
    }
    ///Transaction status
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Transaction status",
    ///  "type": "string",
    ///  "enum": [
    ///    "UNKNOWN",
    ///    "SUCCEEDED",
    ///    "FAILED"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum TransactionStatus {
        #[serde(rename = "UNKNOWN")]
        Unknown,
        #[serde(rename = "SUCCEEDED")]
        Succeeded,
        #[serde(rename = "FAILED")]
        Failed,
    }
    impl ::std::convert::From<&Self> for TransactionStatus {
        fn from(value: &TransactionStatus) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for TransactionStatus {
        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 TransactionStatus {
        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 TransactionStatus {
        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 TransactionStatus {
        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 TransactionStatus {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    ///`TransferDirection`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "string",
    ///  "enum": [
    ///    "sent",
    ///    "received"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        ::serde::Deserialize,
        ::serde::Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd
    )]
    pub enum TransferDirection {
        #[serde(rename = "sent")]
        Sent,
        #[serde(rename = "received")]
        Received,
    }
    impl ::std::convert::From<&Self> for TransferDirection {
        fn from(value: &TransferDirection) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for TransferDirection {
        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 TransferDirection {
        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 TransferDirection {
        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 TransferDirection {
        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 TransferDirection {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    ///`TransferTotalResponse`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "total"
    ///  ],
    ///  "properties": {
    ///    "total": {
    ///      "description": "Total number of transfers",
    ///      "examples": [
    ///        125
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct TransferTotalResponse {
        ///Total number of transfers
        pub total: i64,
    }
    impl ::std::convert::From<&TransferTotalResponse> for TransferTotalResponse {
        fn from(value: &TransferTotalResponse) -> Self {
            value.clone()
        }
    }
    impl TransferTotalResponse {
        pub fn builder() -> builder::TransferTotalResponse {
            Default::default()
        }
    }
    ///Request to update a webhook endpoint
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Request to update a webhook endpoint",
    ///  "type": "object",
    ///  "required": [
    ///    "endpointId"
    ///  ],
    ///  "properties": {
    ///    "channels": {
    ///      "description": "Webhook event channels to subscribe to",
    ///      "type": "array",
    ///      "items": {
    ///        "$ref": "#/components/schemas/WebhookChannel"
    ///      }
    ///    },
    ///    "description": {
    ///      "description": "Endpoint description",
    ///      "examples": [
    ///        "Webhook description"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "disabled": {
    ///      "description": "Whether the endpoint is disabled",
    ///      "examples": [
    ///        false
    ///      ],
    ///      "type": "boolean"
    ///    },
    ///    "endpointId": {
    ///      "description": "Endpoint ID",
    ///      "examples": [
    ///        "ep_01HT7Z4QJ7N2Q9W8P6V3K5M1X2"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "filter": {
    ///      "description": "Event filter configuration",
    ///      "type": "string"
    ///    },
    ///    "filterTypes": {
    ///      "description": "Event type filters",
    ///      "type": "array",
    ///      "items": {
    ///        "type": "string"
    ///      }
    ///    },
    ///    "metadata": {
    ///      "description": "Endpoint metadata",
    ///      "examples": [
    ///        {
    ///          "key": "value"
    ///        }
    ///      ],
    ///      "type": "object",
    ///      "additionalProperties": {}
    ///    },
    ///    "rateLimit": {
    ///      "description": "Rate limit for the endpoint",
    ///      "examples": [
    ///        1000
    ///      ],
    ///      "type": "integer",
    ///      "format": "int32",
    ///      "minimum": 0.0
    ///    },
    ///    "url": {
    ///      "description": "Webhook destination URL",
    ///      "examples": [
    ///        "https://example.com"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct UpdateWebhookRequest {
        ///Webhook event channels to subscribe to
        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
        pub channels: ::std::vec::Vec<WebhookChannel>,
        ///Endpoint description
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub description: ::std::option::Option<::std::string::String>,
        ///Whether the endpoint is disabled
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub disabled: ::std::option::Option<bool>,
        ///Endpoint ID
        #[serde(rename = "endpointId")]
        pub endpoint_id: ::std::string::String,
        ///Event filter configuration
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub filter: ::std::option::Option<::std::string::String>,
        ///Event type filters
        #[serde(
            rename = "filterTypes",
            default,
            skip_serializing_if = "::std::vec::Vec::is_empty"
        )]
        pub filter_types: ::std::vec::Vec<::std::string::String>,
        ///Endpoint metadata
        #[serde(default, skip_serializing_if = "::serde_json::Map::is_empty")]
        pub metadata: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
        ///Rate limit for the endpoint
        #[serde(
            rename = "rateLimit",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub rate_limit: ::std::option::Option<i32>,
        ///Webhook destination URL
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub url: ::std::option::Option<::std::string::String>,
    }
    impl ::std::convert::From<&UpdateWebhookRequest> for UpdateWebhookRequest {
        fn from(value: &UpdateWebhookRequest) -> Self {
            value.clone()
        }
    }
    impl UpdateWebhookRequest {
        pub fn builder() -> builder::UpdateWebhookRequest {
            Default::default()
        }
    }
    ///Wallet balances
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Wallet balances",
    ///  "type": "object",
    ///  "required": [
    ///    "chain",
    ///    "tokens",
    ///    "walletAddress"
    ///  ],
    ///  "properties": {
    ///    "chain": {
    ///      "description": "Chain identifier",
    ///      "examples": [
    ///        "sol"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "nativeBalance": {
    ///      "description": "Native token balance",
    ///      "examples": [
    ///        "0.5"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "nativeBalanceInUsd": {
    ///      "description": "Native balance in USD",
    ///      "examples": [
    ///        "75.00"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "tokens": {
    ///      "description": "Token balances",
    ///      "type": "array",
    ///      "items": {
    ///        "$ref": "#/components/schemas/TokenBalance"
    ///      }
    ///    },
    ///    "totalValueInUsd": {
    ///      "description": "Total value in USD",
    ///      "examples": [
    ///        "3.369918"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "walletAddress": {
    ///      "description": "Wallet address",
    ///      "examples": [
    ///        "8X35rQUK2u9hfn8rMPwwr6ZSEUhbmfDPEapp589XyoM1"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct WalletBalances {
        ///Chain identifier
        pub chain: ::std::string::String,
        ///Native token balance
        #[serde(
            rename = "nativeBalance",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub native_balance: ::std::option::Option<::std::string::String>,
        ///Native balance in USD
        #[serde(
            rename = "nativeBalanceInUsd",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub native_balance_in_usd: ::std::option::Option<::std::string::String>,
        ///Token balances
        pub tokens: ::std::vec::Vec<TokenBalance>,
        ///Total value in USD
        #[serde(
            rename = "totalValueInUsd",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub total_value_in_usd: ::std::option::Option<::std::string::String>,
        ///Wallet address
        #[serde(rename = "walletAddress")]
        pub wallet_address: ::std::string::String,
    }
    impl ::std::convert::From<&WalletBalances> for WalletBalances {
        fn from(value: &WalletBalances) -> Self {
            value.clone()
        }
    }
    impl WalletBalances {
        pub fn builder() -> builder::WalletBalances {
            Default::default()
        }
    }
    ///Wallet first transaction summary
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Wallet first transaction summary",
    ///  "type": "object",
    ///  "required": [
    ///    "balanceChange",
    ///    "blockNumber",
    ///    "blockTime",
    ///    "decimals",
    ///    "tokenAddress",
    ///    "txHash"
    ///  ],
    ///  "properties": {
    ///    "balanceChange": {
    ///      "description": "Balance change from first transaction",
    ///      "examples": [
    ///        "0"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "blockNumber": {
    ///      "description": "Block number",
    ///      "examples": [
    ///        398645949
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "blockTime": {
    ///      "description": "Block timestamp (milliseconds)",
    ///      "examples": [
    ///        1717292678000
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "decimals": {
    ///      "description": "Token decimal places",
    ///      "examples": [
    ///        9
    ///      ],
    ///      "type": "integer",
    ///      "format": "int32"
    ///    },
    ///    "tokenAddress": {
    ///      "description": "Token contract address",
    ///      "examples": [
    ///        "11111111111111111111111111111111"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "txHash": {
    ///      "description": "First funded transaction hash",
    ///      "examples": [
    ///        "5rG9igZk95gbS8ZG66upvRfbcaaDpokQYg4ny3WQ3DrA..."
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct WalletFirstTx {
        ///Balance change from first transaction
        #[serde(rename = "balanceChange")]
        pub balance_change: ::std::string::String,
        ///Block number
        #[serde(rename = "blockNumber")]
        pub block_number: i64,
        ///Block timestamp (milliseconds)
        #[serde(rename = "blockTime")]
        pub block_time: i64,
        ///Token decimal places
        pub decimals: i32,
        ///Token contract address
        #[serde(rename = "tokenAddress")]
        pub token_address: ::std::string::String,
        ///First funded transaction hash
        #[serde(rename = "txHash")]
        pub tx_hash: ::std::string::String,
    }
    impl ::std::convert::From<&WalletFirstTx> for WalletFirstTx {
        fn from(value: &WalletFirstTx) -> Self {
            value.clone()
        }
    }
    impl WalletFirstTx {
        pub fn builder() -> builder::WalletFirstTx {
            Default::default()
        }
    }
    ///Wallet net worth summary
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Wallet net worth summary",
    ///  "type": "object",
    ///  "required": [
    ///    "chain",
    ///    "walletAddress"
    ///  ],
    ///  "properties": {
    ///    "chain": {
    ///      "description": "Blockchain network identifier",
    ///      "examples": [
    ///        "sol"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "tokenCount": {
    ///      "description": "Number of tokens held",
    ///      "examples": [
    ///        5
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "totalValueInNative": {
    ///      "description": "Total portfolio value in native token",
    ///      "examples": [
    ///        "0.002"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "totalValueInUsd": {
    ///      "description": "Total portfolio value in USD",
    ///      "examples": [
    ///        "3.369918"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "walletAddress": {
    ///      "description": "Wallet address",
    ///      "examples": [
    ///        "8X35rQUK2u9hfn8rMPwwr6ZSEUhbmfDPEapp589XyoM1"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct WalletNetWorth {
        ///Blockchain network identifier
        pub chain: ::std::string::String,
        ///Number of tokens held
        #[serde(
            rename = "tokenCount",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub token_count: ::std::option::Option<i64>,
        ///Total portfolio value in native token
        #[serde(
            rename = "totalValueInNative",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub total_value_in_native: ::std::option::Option<::std::string::String>,
        ///Total portfolio value in USD
        #[serde(
            rename = "totalValueInUsd",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub total_value_in_usd: ::std::option::Option<::std::string::String>,
        ///Wallet address
        #[serde(rename = "walletAddress")]
        pub wallet_address: ::std::string::String,
    }
    impl ::std::convert::From<&WalletNetWorth> for WalletNetWorth {
        fn from(value: &WalletNetWorth) -> Self {
            value.clone()
        }
    }
    impl WalletNetWorth {
        pub fn builder() -> builder::WalletNetWorth {
            Default::default()
        }
    }
    ///Wallet net-worth chart response with pagination.
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Wallet net-worth chart response with pagination.",
    ///  "type": "object",
    ///  "required": [
    ///    "currentTimestamp",
    ///    "history",
    ///    "pastTimestamp",
    ///    "walletAddress"
    ///  ],
    ///  "properties": {
    ///    "currentTimestamp": {
    ///      "description": "Current server timestamp",
    ///      "examples": [
    ///        "2025-07-31T23:59:59.000Z"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "history": {
    ///      "description": "List of historical net-worth data points",
    ///      "type": "array",
    ///      "items": {
    ///        "$ref": "#/components/schemas/NetWorthHistoryItem"
    ///      }
    ///    },
    ///    "pastTimestamp": {
    ///      "description": "Start timestamp of chart period",
    ///      "examples": [
    ///        "2025-07-01T23:59:59.000Z"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "walletAddress": {
    ///      "description": "Wallet address",
    ///      "examples": [
    ///        "3xd4LGVWtYXLBspR6X5JWbW49NXmEehfPtX6Kqx98b4w"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct WalletNetWorthChartResponse {
        ///Current server timestamp
        #[serde(rename = "currentTimestamp")]
        pub current_timestamp: ::std::string::String,
        ///List of historical net-worth data points
        pub history: ::std::vec::Vec<NetWorthHistoryItem>,
        ///Start timestamp of chart period
        #[serde(rename = "pastTimestamp")]
        pub past_timestamp: ::std::string::String,
        ///Wallet address
        #[serde(rename = "walletAddress")]
        pub wallet_address: ::std::string::String,
    }
    impl ::std::convert::From<&WalletNetWorthChartResponse>
    for WalletNetWorthChartResponse {
        fn from(value: &WalletNetWorthChartResponse) -> Self {
            value.clone()
        }
    }
    impl WalletNetWorthChartResponse {
        pub fn builder() -> builder::WalletNetWorthChartResponse {
            Default::default()
        }
    }
    ///Paginated wallet net-worth details (mirrors TS WalletNetWorthDetailsPage).
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Paginated wallet net-worth details (mirrors TS WalletNetWorthDetailsPage).",
    ///  "type": "object",
    ///  "required": [
    ///    "data",
    ///    "netWorth",
    ///    "requestedTimestamp",
    ///    "resolvedTimestamp",
    ///    "walletAddress"
    ///  ],
    ///  "properties": {
    ///    "data": {
    ///      "description": "List of token net-worth items",
    ///      "type": "array",
    ///      "items": {
    ///        "$ref": "#/components/schemas/NetWorthByTokensItem"
    ///      }
    ///    },
    ///    "endCursor": {
    ///      "description": "Cursor for the end of current page",
    ///      "examples": [
    ///        "eyJpZCI6ImVuZCJ9"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "hasNext": {
    ///      "description": "Whether there is a next page",
    ///      "examples": [
    ///        false
    ///      ],
    ///      "type": "boolean"
    ///    },
    ///    "hasPrev": {
    ///      "description": "Whether there is a previous page",
    ///      "examples": [
    ///        false
    ///      ],
    ///      "type": "boolean"
    ///    },
    ///    "netWorth": {
    ///      "description": "Net worth value in USD",
    ///      "examples": [
    ///        "11839478.53162622"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "requestedTimestamp": {
    ///      "description": "Requested snapshot timestamp",
    ///      "examples": [
    ///        "2025-07-31T04:50:06.303Z"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "resolvedTimestamp": {
    ///      "description": "Actual resolved snapshot timestamp",
    ///      "examples": [
    ///        "2025-07-31T04:50:06.475Z"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "startCursor": {
    ///      "description": "Cursor for the start of current page",
    ///      "examples": [
    ///        "eyJpZCI6InN0YXJ0In0="
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "walletAddress": {
    ///      "description": "Wallet address",
    ///      "examples": [
    ///        "3xd4LGVWtYXLBspR6X5JWbW49NXmEehfPtX6Kqx98b4w"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct WalletNetWorthDetailsPage {
        ///List of token net-worth items
        pub data: ::std::vec::Vec<NetWorthByTokensItem>,
        ///Cursor for the end of current page
        #[serde(
            rename = "endCursor",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub end_cursor: ::std::option::Option<::std::string::String>,
        ///Whether there is a next page
        #[serde(
            rename = "hasNext",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub has_next: ::std::option::Option<bool>,
        ///Whether there is a previous page
        #[serde(
            rename = "hasPrev",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub has_prev: ::std::option::Option<bool>,
        ///Net worth value in USD
        #[serde(rename = "netWorth")]
        pub net_worth: ::std::string::String,
        ///Requested snapshot timestamp
        #[serde(rename = "requestedTimestamp")]
        pub requested_timestamp: ::std::string::String,
        ///Actual resolved snapshot timestamp
        #[serde(rename = "resolvedTimestamp")]
        pub resolved_timestamp: ::std::string::String,
        ///Cursor for the start of current page
        #[serde(
            rename = "startCursor",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub start_cursor: ::std::option::Option<::std::string::String>,
        ///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()
        }
    }
    ///Paginated wallet net-worth page (mirrors TS WalletNetWorthPage).
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Paginated wallet net-worth page (mirrors TS WalletNetWorthPage).",
    ///  "type": "object",
    ///  "required": [
    ///    "currentTimestamp",
    ///    "data",
    ///    "totalValueInNative",
    ///    "totalValueInUsd",
    ///    "walletAddress"
    ///  ],
    ///  "properties": {
    ///    "currentTimestamp": {
    ///      "description": "Current server timestamp",
    ///      "examples": [
    ///        "2025-10-30T03:33:40.980Z"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "data": {
    ///      "description": "List of token net-worth items",
    ///      "type": "array",
    ///      "items": {
    ///        "$ref": "#/components/schemas/NetWorthByTokensItem"
    ///      }
    ///    },
    ///    "endCursor": {
    ///      "description": "Cursor for the end of current page",
    ///      "examples": [
    ///        "eyJpZCI6ImVuZCJ9"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "hasNext": {
    ///      "description": "Whether there is a next page",
    ///      "examples": [
    ///        false
    ///      ],
    ///      "type": "boolean"
    ///    },
    ///    "hasPrev": {
    ///      "description": "Whether there is a previous page",
    ///      "examples": [
    ///        false
    ///      ],
    ///      "type": "boolean"
    ///    },
    ///    "startCursor": {
    ///      "description": "Cursor for the start of current page",
    ///      "examples": [
    ///        "eyJpZCI6InN0YXJ0In0="
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "totalValueInNative": {
    ///      "description": "Total portfolio value in native token",
    ///      "examples": [
    ///        "82.31"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "totalValueInUsd": {
    ///      "description": "Total portfolio value in USD",
    ///      "examples": [
    ///        "12345.67"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "walletAddress": {
    ///      "description": "Wallet address",
    ///      "examples": [
    ///        "3xd4LGVWtYXLBspR6X5JWbW49NXmEehfPtX6Kqx98b4w"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct WalletNetWorthPage {
        ///Current server timestamp
        #[serde(rename = "currentTimestamp")]
        pub current_timestamp: ::std::string::String,
        ///List of token net-worth items
        pub data: ::std::vec::Vec<NetWorthByTokensItem>,
        ///Cursor for the end of current page
        #[serde(
            rename = "endCursor",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub end_cursor: ::std::option::Option<::std::string::String>,
        ///Whether there is a next page
        #[serde(
            rename = "hasNext",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub has_next: ::std::option::Option<bool>,
        ///Whether there is a previous page
        #[serde(
            rename = "hasPrev",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub has_prev: ::std::option::Option<bool>,
        ///Cursor for the start of current page
        #[serde(
            rename = "startCursor",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub start_cursor: ::std::option::Option<::std::string::String>,
        ///Total portfolio value in native token
        #[serde(rename = "totalValueInNative")]
        pub total_value_in_native: ::std::string::String,
        ///Total portfolio value in USD
        #[serde(rename = "totalValueInUsd")]
        pub total_value_in_usd: ::std::string::String,
        ///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()
        }
    }
    ///`WalletNetWorthSummaryResponse`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "currentTimestamp",
    ///    "wallets"
    ///  ],
    ///  "properties": {
    ///    "currentTimestamp": {
    ///      "description": "Current server timestamp",
    ///      "examples": [
    ///        "2025-10-30T03:33:40.980Z"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "wallets": {
    ///      "description": "Map of wallet addresses to net-worth values",
    ///      "examples": [
    ///        {
    ///          "3bovD5jCRn7eG64jZqyEz6Zbx92mHixZSTRrWLy1Sirx": {
    ///            "value": "1764819473.530063"
    ///          }
    ///        }
    ///      ],
    ///      "type": "object",
    ///      "additionalProperties": {
    ///        "$ref": "#/components/schemas/NetWorthSummaryValue"
    ///      }
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct WalletNetWorthSummaryResponse {
        ///Current server timestamp
        #[serde(rename = "currentTimestamp")]
        pub current_timestamp: ::std::string::String,
        ///Map of wallet addresses to net-worth values
        pub wallets: ::std::collections::HashMap<
            ::std::string::String,
            NetWorthSummaryValue,
        >,
    }
    impl ::std::convert::From<&WalletNetWorthSummaryResponse>
    for WalletNetWorthSummaryResponse {
        fn from(value: &WalletNetWorthSummaryResponse) -> Self {
            value.clone()
        }
    }
    impl WalletNetWorthSummaryResponse {
        pub fn builder() -> builder::WalletNetWorthSummaryResponse {
            Default::default()
        }
    }
    ///Wallet PnL Summary (aggregated across all tokens for a given resolution)
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Wallet PnL Summary (aggregated across all tokens for a given resolution)",
    ///  "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": "Average profit per trade in USD",
    ///      "examples": [
    ///        "402.86"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "buyAmountInUsd": {
    ///      "description": "Total buy amount in USD",
    ///      "examples": [
    ///        "101371192.39"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "buys": {
    ///      "description": "Total number of buy trades",
    ///      "examples": [
    ///        "1515999"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "losses": {
    ///      "description": "Number of losing trades",
    ///      "examples": [
    ///        "348350"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "realizedProfitInUsd": {
    ///      "description": "Realized profit in USD",
    ///      "examples": [
    ///        "802583.91"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "realizedProfitRatio": {
    ///      "description": "Realized profit ratio",
    ///      "examples": [
    ///        "0.0035521324"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "resolution": {
    ///      "description": "PnL time resolution",
    ///      "examples": [
    ///        "1d"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "sellAmountInUsd": {
    ///      "description": "Total sell amount in USD",
    ///      "examples": [
    ///        "60369621.10"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "sells": {
    ///      "description": "Total number of sell trades",
    ///      "examples": [
    ///        "1011994"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "tokens": {
    ///      "description": "Total number of traded tokens",
    ///      "examples": [
    ///        "15126"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "totalCostInUsd": {
    ///      "description": "Total cost basis in USD",
    ///      "examples": [
    ///        "225944253.64"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "totalProfitInUsd": {
    ///      "description": "Total profit (realized + unrealized) in USD",
    ///      "examples": [
    ///        "1018427683.08"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "totalProfitRatio": {
    ///      "description": "Total profit ratio",
    ///      "examples": [
    ///        "4.5074290081"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "totalTrades": {
    ///      "description": "Total number of all trades",
    ///      "examples": [
    ///        "2527993"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "unrealizedProfitInUsd": {
    ///      "description": "Unrealized profit in USD",
    ///      "examples": [
    ///        "1017625099.17"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "unrealizedProfitRatio": {
    ///      "description": "Unrealized profit ratio",
    ///      "examples": [
    ///        "4.5038768756"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "updatedAt": {
    ///      "description": "Last updated timestamp",
    ///      "examples": [
    ///        "2026-02-04T11:42:50.000Z"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "walletAddress": {
    ///      "description": "Wallet address",
    ///      "examples": [
    ///        "54Pz1e35z9uoFdnxtzjp7xZQoFiofqhdayQWBMN7dsuy"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "winRate": {
    ///      "description": "Ratio of winning trades to total trades",
    ///      "examples": [
    ///        "0.5575"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "wins": {
    ///      "description": "Number of profitable trades",
    ///      "examples": [
    ///        "438944"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct WalletPnlSummary {
        ///Average profit per trade in USD
        #[serde(rename = "avgProfitPerTradeInUsd")]
        pub avg_profit_per_trade_in_usd: ::std::string::String,
        ///Total buy amount in USD
        #[serde(rename = "buyAmountInUsd")]
        pub buy_amount_in_usd: ::std::string::String,
        ///Total number of buy trades
        pub buys: ::std::string::String,
        ///Number of losing trades
        pub losses: ::std::string::String,
        ///Realized profit in USD
        #[serde(rename = "realizedProfitInUsd")]
        pub realized_profit_in_usd: ::std::string::String,
        ///Realized profit ratio
        #[serde(rename = "realizedProfitRatio")]
        pub realized_profit_ratio: ::std::string::String,
        ///PnL time resolution
        pub resolution: ::std::string::String,
        ///Total sell amount in USD
        #[serde(rename = "sellAmountInUsd")]
        pub sell_amount_in_usd: ::std::string::String,
        ///Total number of sell trades
        pub sells: ::std::string::String,
        ///Total number of traded tokens
        pub tokens: ::std::string::String,
        ///Total cost basis in USD
        #[serde(rename = "totalCostInUsd")]
        pub total_cost_in_usd: ::std::string::String,
        ///Total profit (realized + unrealized) in USD
        #[serde(rename = "totalProfitInUsd")]
        pub total_profit_in_usd: ::std::string::String,
        ///Total profit ratio
        #[serde(rename = "totalProfitRatio")]
        pub total_profit_ratio: ::std::string::String,
        ///Total number of all trades
        #[serde(rename = "totalTrades")]
        pub total_trades: ::std::string::String,
        ///Unrealized profit in USD
        #[serde(rename = "unrealizedProfitInUsd")]
        pub unrealized_profit_in_usd: ::std::string::String,
        ///Unrealized profit ratio
        #[serde(rename = "unrealizedProfitRatio")]
        pub unrealized_profit_ratio: ::std::string::String,
        ///Last updated timestamp
        #[serde(
            rename = "updatedAt",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub updated_at: ::std::option::Option<::std::string::String>,
        ///Wallet address
        #[serde(rename = "walletAddress")]
        pub wallet_address: ::std::string::String,
        ///Ratio of winning trades to total trades
        #[serde(rename = "winRate")]
        pub win_rate: ::std::string::String,
        ///Number of profitable trades
        pub wins: ::std::string::String,
    }
    impl ::std::convert::From<&WalletPnlSummary> for WalletPnlSummary {
        fn from(value: &WalletPnlSummary) -> Self {
            value.clone()
        }
    }
    impl WalletPnlSummary {
        pub fn builder() -> builder::WalletPnlSummary {
            Default::default()
        }
    }
    ///Wallet transfer
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Wallet transfer",
    ///  "type": "object",
    ///  "required": [
    ///    "amount",
    ///    "blockTimestamp",
    ///    "fromAddress",
    ///    "id",
    ///    "toAddress",
    ///    "tokenAddress",
    ///    "transactionSignature",
    ///    "transferType"
    ///  ],
    ///  "properties": {
    ///    "amount": {
    ///      "description": "Transfer amount in token units",
    ///      "examples": [
    ///        "1.5"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "amountInUsd": {
    ///      "description": "Transfer amount in USD",
    ///      "examples": [
    ///        "225.00"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "blockTimestamp": {
    ///      "description": "Block timestamp (milliseconds)",
    ///      "examples": [
    ///        1717334400000
    ///      ],
    ///      "type": "integer",
    ///      "format": "int64"
    ///    },
    ///    "fromAddress": {
    ///      "description": "Sender address",
    ///      "examples": [
    ///        "54Pz1e35z9uoFdnxtzjp7xZQoFiofqhdayQWBMN7dsuy"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "id": {
    ///      "description": "Transfer record identifier",
    ///      "examples": [
    ///        "transfer-123"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "toAddress": {
    ///      "description": "Receiver address",
    ///      "examples": [
    ///        "8X35rQUK2u9hfn8rMPwwr6ZSEUhbmfDPEapp589XyoM1"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "tokenAddress": {
    ///      "description": "Token contract address",
    ///      "examples": [
    ///        "So11111111111111111111111111111111111111112"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "transactionSignature": {
    ///      "description": "Transaction signature",
    ///      "examples": [
    ///        "4tEHfECrLJm8N7dNCfQSjhLG7LqdMuZhzBhRy7VRhjCt"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "transferType": {
    ///      "description": "Transfer type (SEND or RECEIVE)",
    ///      "examples": [
    ///        "SEND"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct WalletTransfer {
        ///Transfer amount in token units
        pub amount: ::std::string::String,
        ///Transfer amount in USD
        #[serde(
            rename = "amountInUsd",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub amount_in_usd: ::std::option::Option<::std::string::String>,
        ///Block timestamp (milliseconds)
        #[serde(rename = "blockTimestamp")]
        pub block_timestamp: i64,
        ///Sender address
        #[serde(rename = "fromAddress")]
        pub from_address: ::std::string::String,
        ///Transfer record identifier
        pub id: ::std::string::String,
        ///Receiver address
        #[serde(rename = "toAddress")]
        pub to_address: ::std::string::String,
        ///Token contract address
        #[serde(rename = "tokenAddress")]
        pub token_address: ::std::string::String,
        ///Transaction signature
        #[serde(rename = "transactionSignature")]
        pub transaction_signature: ::std::string::String,
        ///Transfer type (SEND or RECEIVE)
        #[serde(rename = "transferType")]
        pub transfer_type: ::std::string::String,
    }
    impl ::std::convert::From<&WalletTransfer> for WalletTransfer {
        fn from(value: &WalletTransfer) -> Self {
            value.clone()
        }
    }
    impl WalletTransfer {
        pub fn builder() -> builder::WalletTransfer {
            Default::default()
        }
    }
    ///`WalletsMapResponse`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "wallets"
    ///  ],
    ///  "properties": {
    ///    "wallets": {
    ///      "description": "Map of wallet addresses to first transaction info",
    ///      "examples": [
    ///        {
    ///          "3bovD5jCRn7eG64jZqyEz6Zbx92mHixZSTRrWLy1Sirx": {
    ///            "balanceChange": "0",
    ///            "blockNumber": 398645949,
    ///            "blockTime": 1717292678000,
    ///            "decimals": 9,
    ///            "tokenAddress": "11111111111111111111111111111111",
    ///            "txHash": "5rG9igZk95gbS8ZG66upvRfbcaaDpokQYg4ny3WQ3DrA..."
    ///          }
    ///        }
    ///      ],
    ///      "type": "object",
    ///      "additionalProperties": {
    ///        "$ref": "#/components/schemas/WalletFirstTx"
    ///      }
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct WalletsMapResponse {
        ///Map of wallet addresses to first transaction info
        pub wallets: ::std::collections::HashMap<::std::string::String, WalletFirstTx>,
    }
    impl ::std::convert::From<&WalletsMapResponse> for WalletsMapResponse {
        fn from(value: &WalletsMapResponse) -> Self {
            value.clone()
        }
    }
    impl WalletsMapResponse {
        pub fn builder() -> builder::WalletsMapResponse {
            Default::default()
        }
    }
    ///Watchlist entity
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Watchlist entity",
    ///  "type": "object",
    ///  "required": [
    ///    "items",
    ///    "userId"
    ///  ],
    ///  "properties": {
    ///    "items": {
    ///      "description": "List of watchlist items",
    ///      "type": "array",
    ///      "items": {
    ///        "$ref": "#/components/schemas/WatchlistItem"
    ///      }
    ///    },
    ///    "userId": {
    ///      "description": "User ID or identifier",
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct Watchlist {
        ///List of watchlist items
        pub items: ::std::vec::Vec<WatchlistItem>,
        ///User ID or identifier
        #[serde(rename = "userId")]
        pub user_id: ::std::string::String,
    }
    impl ::std::convert::From<&Watchlist> for Watchlist {
        fn from(value: &Watchlist) -> Self {
            value.clone()
        }
    }
    impl Watchlist {
        pub fn builder() -> builder::Watchlist {
            Default::default()
        }
    }
    ///`WatchlistAddResponseModel`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "success"
    ///  ],
    ///  "properties": {
    ///    "success": {
    ///      "description": "Whether the address was added successfully",
    ///      "examples": [
    ///        true
    ///      ],
    ///      "type": "boolean"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct WatchlistAddResponseModel {
        ///Whether the address was added successfully
        pub success: bool,
    }
    impl ::std::convert::From<&WatchlistAddResponseModel> for WatchlistAddResponseModel {
        fn from(value: &WatchlistAddResponseModel) -> Self {
            value.clone()
        }
    }
    impl WatchlistAddResponseModel {
        pub fn builder() -> builder::WatchlistAddResponseModel {
            Default::default()
        }
    }
    ///Watchlist item
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Watchlist item",
    ///  "type": "object",
    ///  "required": [
    ///    "chain",
    ///    "walletAddress"
    ///  ],
    ///  "properties": {
    ///    "chain": {
    ///      "description": "Chain identifier",
    ///      "type": "string"
    ///    },
    ///    "walletAddress": {
    ///      "description": "Wallet address being watched",
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct WatchlistItem {
        ///Chain identifier
        pub chain: ::std::string::String,
        ///Wallet address being watched
        #[serde(rename = "walletAddress")]
        pub wallet_address: ::std::string::String,
    }
    impl ::std::convert::From<&WatchlistItem> for WatchlistItem {
        fn from(value: &WatchlistItem) -> Self {
            value.clone()
        }
    }
    impl WatchlistItem {
        pub fn builder() -> builder::WatchlistItem {
            Default::default()
        }
    }
    ///Webhook event channel
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Webhook event channel",
    ///  "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 WebhookChannel {
        #[serde(rename = "sol.token.migrated")]
        SolTokenMigrated,
        #[serde(rename = "sol.token.created")]
        SolTokenCreated,
    }
    impl ::std::convert::From<&Self> for WebhookChannel {
        fn from(value: &WebhookChannel) -> Self {
            value.clone()
        }
    }
    impl ::std::fmt::Display for WebhookChannel {
        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 WebhookChannel {
        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 WebhookChannel {
        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 WebhookChannel {
        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 WebhookChannel {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }
    ///Webhook endpoint response
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Webhook endpoint response",
    ///  "type": "object",
    ///  "required": [
    ///    "id",
    ///    "url"
    ///  ],
    ///  "properties": {
    ///    "channels": {
    ///      "description": "Webhook event channels to subscribe to",
    ///      "type": "array",
    ///      "items": {
    ///        "$ref": "#/components/schemas/WebhookChannel"
    ///      }
    ///    },
    ///    "createdAt": {
    ///      "description": "Endpoint creation timestamp",
    ///      "examples": [
    ///        "2021-01-01"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "description": {
    ///      "description": "Endpoint description",
    ///      "examples": [
    ///        "Webhook description"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "disabled": {
    ///      "description": "Whether the endpoint is disabled",
    ///      "examples": [
    ///        false
    ///      ],
    ///      "type": "boolean"
    ///    },
    ///    "filter": {
    ///      "description": "Event filter configuration",
    ///      "type": "string"
    ///    },
    ///    "filterTypes": {
    ///      "description": "Event type filters",
    ///      "type": "array",
    ///      "items": {
    ///        "type": "string"
    ///      }
    ///    },
    ///    "id": {
    ///      "description": "Endpoint internal ID",
    ///      "examples": [
    ///        "ep_01HT7Z4QJ7N2Q9W8P6V3K5M1X2"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "metadata": {
    ///      "description": "Endpoint metadata",
    ///      "examples": [
    ///        {
    ///          "key": "value"
    ///        }
    ///      ],
    ///      "type": "object",
    ///      "additionalProperties": {}
    ///    },
    ///    "rateLimit": {
    ///      "description": "Rate limit for the endpoint",
    ///      "examples": [
    ///        1000
    ///      ],
    ///      "type": "integer",
    ///      "format": "int32",
    ///      "minimum": 0.0
    ///    },
    ///    "updatedAt": {
    ///      "description": "Endpoint last updated timestamp",
    ///      "examples": [
    ///        "2021-01-01"
    ///      ],
    ///      "type": "string"
    ///    },
    ///    "url": {
    ///      "description": "Webhook destination URL",
    ///      "examples": [
    ///        "https://example.com"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(::serde::Deserialize, ::serde::Serialize, Clone, Debug)]
    pub struct WebhookEndpoint {
        ///Webhook event channels to subscribe to
        #[serde(default, skip_serializing_if = "::std::vec::Vec::is_empty")]
        pub channels: ::std::vec::Vec<WebhookChannel>,
        ///Endpoint creation timestamp
        #[serde(
            rename = "createdAt",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub created_at: ::std::option::Option<::std::string::String>,
        ///Endpoint description
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub description: ::std::option::Option<::std::string::String>,
        ///Whether the endpoint is disabled
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub disabled: ::std::option::Option<bool>,
        ///Event filter configuration
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub filter: ::std::option::Option<::std::string::String>,
        ///Event type filters
        #[serde(
            rename = "filterTypes",
            default,
            skip_serializing_if = "::std::vec::Vec::is_empty"
        )]
        pub filter_types: ::std::vec::Vec<::std::string::String>,
        ///Endpoint internal ID
        pub id: ::std::string::String,
        ///Endpoint metadata
        #[serde(default, skip_serializing_if = "::serde_json::Map::is_empty")]
        pub metadata: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
        ///Rate limit for the endpoint
        #[serde(
            rename = "rateLimit",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub rate_limit: ::std::option::Option<i32>,
        ///Endpoint last updated timestamp
        #[serde(
            rename = "updatedAt",
            default,
            skip_serializing_if = "::std::option::Option::is_none"
        )]
        pub updated_at: ::std::option::Option<::std::string::String>,
        ///Webhook destination URL
        pub url: ::std::string::String,
    }
    impl ::std::convert::From<&WebhookEndpoint> for WebhookEndpoint {
        fn from(value: &WebhookEndpoint) -> Self {
            value.clone()
        }
    }
    impl WebhookEndpoint {
        pub fn builder() -> builder::WebhookEndpoint {
            Default::default()
        }
    }
    /// Types for composing complex structures.
    pub mod builder {
        #[derive(Clone, Debug)]
        pub struct BalanceUpdate {
            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<
                ::std::option::Option<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 BalanceUpdate {
            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: Ok(Default::default()),
                    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 BalanceUpdate {
            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<::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 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<BalanceUpdate> for super::BalanceUpdate {
            type Error = super::error::ConversionError;
            fn try_from(
                value: BalanceUpdate,
            ) -> ::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::BalanceUpdate> for BalanceUpdate {
            fn from(value: super::BalanceUpdate) -> 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 Blockchain {
            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 Blockchain {
            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 Blockchain {
            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<Blockchain> for super::Blockchain {
            type Error = super::error::ConversionError;
            fn try_from(
                value: Blockchain,
            ) -> ::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::Blockchain> for Blockchain {
            fn from(value: super::Blockchain) -> 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 BlockchainLatestBlock {
            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 BlockchainLatestBlock {
            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 BlockchainLatestBlock {
            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<BlockchainLatestBlock>
        for super::BlockchainLatestBlock {
            type Error = super::error::ConversionError;
            fn try_from(
                value: BlockchainLatestBlock,
            ) -> ::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::BlockchainLatestBlock>
        for BlockchainLatestBlock {
            fn from(value: super::BlockchainLatestBlock) -> Self {
                Self {
                    blockhash: Ok(value.blockhash),
                    last_valid_block_height: Ok(value.last_valid_block_height),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct BooleanResult {
            result: ::std::result::Result<bool, ::std::string::String>,
        }
        impl ::std::default::Default for BooleanResult {
            fn default() -> Self {
                Self {
                    result: Err("no value supplied for result".to_string()),
                }
            }
        }
        impl BooleanResult {
            pub fn result<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<bool>,
                T::Error: ::std::fmt::Display,
            {
                self.result = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for result: {}", e)
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<BooleanResult> for super::BooleanResult {
            type Error = super::error::ConversionError;
            fn try_from(
                value: BooleanResult,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self { result: value.result? })
            }
        }
        impl ::std::convert::From<super::BooleanResult> for BooleanResult {
            fn from(value: super::BooleanResult) -> Self {
                Self { result: Ok(value.result) }
            }
        }
        #[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 ClaimRedPacketRequest {
            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 ClaimRedPacketRequest {
            fn default() -> Self {
                Self {
                    claimer: Err("no value supplied for claimer".to_string()),
                    packet_id: Ok(Default::default()),
                    password: Ok(Default::default()),
                    share_id: Ok(Default::default()),
                }
            }
        }
        impl ClaimRedPacketRequest {
            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<ClaimRedPacketRequest>
        for super::ClaimRedPacketRequest {
            type Error = super::error::ConversionError;
            fn try_from(
                value: ClaimRedPacketRequest,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    claimer: value.claimer?,
                    packet_id: value.packet_id?,
                    password: value.password?,
                    share_id: value.share_id?,
                })
            }
        }
        impl ::std::convert::From<super::ClaimRedPacketRequest>
        for ClaimRedPacketRequest {
            fn from(value: super::ClaimRedPacketRequest) -> Self {
                Self {
                    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 ClaimRedPacketResponse {
            tx_serialize: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for ClaimRedPacketResponse {
            fn default() -> Self {
                Self {
                    tx_serialize: Err("no value supplied for tx_serialize".to_string()),
                }
            }
        }
        impl ClaimRedPacketResponse {
            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<ClaimRedPacketResponse>
        for super::ClaimRedPacketResponse {
            type Error = super::error::ConversionError;
            fn try_from(
                value: ClaimRedPacketResponse,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    tx_serialize: value.tx_serialize?,
                })
            }
        }
        impl ::std::convert::From<super::ClaimRedPacketResponse>
        for ClaimRedPacketResponse {
            fn from(value: super::ClaimRedPacketResponse) -> Self {
                Self {
                    tx_serialize: Ok(value.tx_serialize),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct CreateRedPacketRequest {
            claim_authority: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            creator: ::std::result::Result<::std::string::String, ::std::string::String>,
            expiration: ::std::result::Result<
                ::std::option::Option<i64>,
                ::std::string::String,
            >,
            fixed_amount: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            max_claims: ::std::result::Result<i32, ::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 CreateRedPacketRequest {
            fn default() -> Self {
                Self {
                    claim_authority: Ok(Default::default()),
                    creator: Err("no value supplied for creator".to_string()),
                    expiration: Ok(Default::default()),
                    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 CreateRedPacketRequest {
            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<::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<::std::option::Option<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 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<i32>,
                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<CreateRedPacketRequest>
        for super::CreateRedPacketRequest {
            type Error = super::error::ConversionError;
            fn try_from(
                value: CreateRedPacketRequest,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    claim_authority: value.claim_authority?,
                    creator: value.creator?,
                    expiration: value.expiration?,
                    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::CreateRedPacketRequest>
        for CreateRedPacketRequest {
            fn from(value: super::CreateRedPacketRequest) -> Self {
                Self {
                    claim_authority: Ok(value.claim_authority),
                    creator: Ok(value.creator),
                    expiration: Ok(value.expiration),
                    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 CreateRedPacketResponse {
            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 CreateRedPacketResponse {
            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 CreateRedPacketResponse {
            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<CreateRedPacketResponse>
        for super::CreateRedPacketResponse {
            type Error = super::error::ConversionError;
            fn try_from(
                value: CreateRedPacketResponse,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    share_id: value.share_id?,
                    tx_serialize: value.tx_serialize?,
                })
            }
        }
        impl ::std::convert::From<super::CreateRedPacketResponse>
        for CreateRedPacketResponse {
            fn from(value: super::CreateRedPacketResponse) -> 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 CreateWebhookRequest {
            channels: ::std::result::Result<
                ::std::vec::Vec<super::WebhookChannel>,
                ::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,
            >,
            metadata: ::std::result::Result<
                ::serde_json::Map<::std::string::String, ::serde_json::Value>,
                ::std::string::String,
            >,
            rate_limit: ::std::result::Result<
                ::std::option::Option<i32>,
                ::std::string::String,
            >,
            secret: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            url: ::std::result::Result<::std::string::String, ::std::string::String>,
        }
        impl ::std::default::Default for CreateWebhookRequest {
            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()),
                    secret: Ok(Default::default()),
                    url: Err("no value supplied for url".to_string()),
                }
            }
        }
        impl CreateWebhookRequest {
            pub fn channels<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::vec::Vec<super::WebhookChannel>>,
                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<::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 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<i32>>,
                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 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
            }
            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<CreateWebhookRequest>
        for super::CreateWebhookRequest {
            type Error = super::error::ConversionError;
            fn try_from(
                value: CreateWebhookRequest,
            ) -> ::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?,
                    secret: value.secret?,
                    url: value.url?,
                })
            }
        }
        impl ::std::convert::From<super::CreateWebhookRequest> for CreateWebhookRequest {
            fn from(value: super::CreateWebhookRequest) -> 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),
                    secret: Ok(value.secret),
                    url: Ok(value.url),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct DevToken {
            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::TokenStats, ::std::string::String>,
        }
        impl ::std::default::Default for DevToken {
            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 DevToken {
            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::TokenStats>,
                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<DevToken> for super::DevToken {
            type Error = super::error::ConversionError;
            fn try_from(
                value: DevToken,
            ) -> ::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::DevToken> for DevToken {
            fn from(value: super::DevToken) -> 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 Dex {
            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<super::DexProtocolFamily>,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for Dex {
            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 Dex {
            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<super::DexProtocolFamily>,
                >,
                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<Dex> for super::Dex {
            type Error = super::error::ConversionError;
            fn try_from(
                value: Dex,
            ) -> ::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::Dex> for Dex {
            fn from(value: super::Dex) -> 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 DexPool {
            chain: ::std::result::Result<::std::string::String, ::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,
            >,
            token_a_address: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            token_b_address: ::std::result::Result<
                ::std::string::String,
                ::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,
            >,
        }
        impl ::std::default::Default for DexPool {
            fn default() -> Self {
                Self {
                    chain: Err("no value supplied for chain".to_string()),
                    pool_address: Err("no value supplied for pool_address".to_string()),
                    program_address: Ok(Default::default()),
                    protocol_family: Ok(Default::default()),
                    token_a_address: Err(
                        "no value supplied for token_a_address".to_string(),
                    ),
                    token_b_address: Err(
                        "no value supplied for token_b_address".to_string(),
                    ),
                    tvl_in_sol: Ok(Default::default()),
                    tvl_in_usd: Ok(Default::default()),
                }
            }
        }
        impl DexPool {
            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 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 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_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 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
            }
        }
        impl ::std::convert::TryFrom<DexPool> for super::DexPool {
            type Error = super::error::ConversionError;
            fn try_from(
                value: DexPool,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    chain: value.chain?,
                    pool_address: value.pool_address?,
                    program_address: value.program_address?,
                    protocol_family: value.protocol_family?,
                    token_a_address: value.token_a_address?,
                    token_b_address: value.token_b_address?,
                    tvl_in_sol: value.tvl_in_sol?,
                    tvl_in_usd: value.tvl_in_usd?,
                })
            }
        }
        impl ::std::convert::From<super::DexPool> for DexPool {
            fn from(value: super::DexPool) -> Self {
                Self {
                    chain: Ok(value.chain),
                    pool_address: Ok(value.pool_address),
                    program_address: Ok(value.program_address),
                    protocol_family: Ok(value.protocol_family),
                    token_a_address: Ok(value.token_a_address),
                    token_b_address: Ok(value.token_b_address),
                    tvl_in_sol: Ok(value.tvl_in_sol),
                    tvl_in_usd: Ok(value.tvl_in_usd),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct DexPoolDetail {
            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<i32>,
                ::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<i32>,
                ::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<i32>,
                ::std::string::String,
            >,
            version: ::std::result::Result<
                ::std::option::Option<i32>,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for DexPoolDetail {
            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 DexPoolDetail {
            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<i32>>,
                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<i32>>,
                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<i32>>,
                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<i32>>,
                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<DexPoolDetail> for super::DexPoolDetail {
            type Error = super::error::ConversionError;
            fn try_from(
                value: DexPoolDetail,
            ) -> ::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::DexPoolDetail> for DexPoolDetail {
            fn from(value: super::DexPoolDetail) -> 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 DexPoolSnapshot {
            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::DexPoolTokenSnapshot,
                ::std::string::String,
            >,
            token_b: ::std::result::Result<
                super::DexPoolTokenSnapshot,
                ::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 DexPoolSnapshot {
            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 DexPoolSnapshot {
            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::DexPoolTokenSnapshot>,
                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::DexPoolTokenSnapshot>,
                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<DexPoolSnapshot> for super::DexPoolSnapshot {
            type Error = super::error::ConversionError;
            fn try_from(
                value: DexPoolSnapshot,
            ) -> ::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::DexPoolSnapshot> for DexPoolSnapshot {
            fn from(value: super::DexPoolSnapshot) -> 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 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<i32, ::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<i32>,
                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 DexPoolTokenSnapshot {
            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<i32, ::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 DexPoolTokenSnapshot {
            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 DexPoolTokenSnapshot {
            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<i32>,
                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<DexPoolTokenSnapshot>
        for super::DexPoolTokenSnapshot {
            type Error = super::error::ConversionError;
            fn try_from(
                value: DexPoolTokenSnapshot,
            ) -> ::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::DexPoolTokenSnapshot> for DexPoolTokenSnapshot {
            fn from(value: super::DexPoolTokenSnapshot) -> 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 DexscrAd {
            ad_type: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            chain: ::std::result::Result<::std::string::String, ::std::string::String>,
            date: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            duration_hours: ::std::result::Result<
                ::std::option::Option<i64>,
                ::std::string::String,
            >,
            impressions: ::std::result::Result<
                ::std::option::Option<i64>,
                ::std::string::String,
            >,
            token_address: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            url: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for DexscrAd {
            fn default() -> Self {
                Self {
                    ad_type: Ok(Default::default()),
                    chain: Err("no value supplied for chain".to_string()),
                    date: Ok(Default::default()),
                    duration_hours: Ok(Default::default()),
                    impressions: Ok(Default::default()),
                    token_address: Err(
                        "no value supplied for token_address".to_string(),
                    ),
                    url: Ok(Default::default()),
                }
            }
        }
        impl DexscrAd {
            pub fn ad_type<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.ad_type = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for ad_type: {}", 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 date<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.date = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for date: {}", e)
                    });
                self
            }
            pub fn duration_hours<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<i64>>,
                T::Error: ::std::fmt::Display,
            {
                self.duration_hours = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for duration_hours: {}", e
                        )
                    });
                self
            }
            pub fn impressions<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<i64>>,
                T::Error: ::std::fmt::Display,
            {
                self.impressions = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for impressions: {}", 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 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<DexscrAd> for super::DexscrAd {
            type Error = super::error::ConversionError;
            fn try_from(
                value: DexscrAd,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    ad_type: value.ad_type?,
                    chain: value.chain?,
                    date: value.date?,
                    duration_hours: value.duration_hours?,
                    impressions: value.impressions?,
                    token_address: value.token_address?,
                    url: value.url?,
                })
            }
        }
        impl ::std::convert::From<super::DexscrAd> for DexscrAd {
            fn from(value: super::DexscrAd) -> Self {
                Self {
                    ad_type: Ok(value.ad_type),
                    chain: Ok(value.chain),
                    date: Ok(value.date),
                    duration_hours: Ok(value.duration_hours),
                    impressions: Ok(value.impressions),
                    token_address: Ok(value.token_address),
                    url: Ok(value.url),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct DexscrBoost {
            amount: ::std::result::Result<
                ::std::option::Option<f64>,
                ::std::string::String,
            >,
            chain: ::std::result::Result<::std::string::String, ::std::string::String>,
            description: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            header: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            icon: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            links: ::std::result::Result<
                ::std::option::Option<::serde_json::Value>,
                ::std::string::String,
            >,
            open_graph: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            token_address: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            total_amount: ::std::result::Result<f64, ::std::string::String>,
            url: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for DexscrBoost {
            fn default() -> Self {
                Self {
                    amount: Ok(Default::default()),
                    chain: Err("no value supplied for chain".to_string()),
                    description: Ok(Default::default()),
                    header: Ok(Default::default()),
                    icon: Ok(Default::default()),
                    links: Ok(Default::default()),
                    open_graph: Ok(Default::default()),
                    token_address: Err(
                        "no value supplied for token_address".to_string(),
                    ),
                    total_amount: Err("no value supplied for total_amount".to_string()),
                    url: Ok(Default::default()),
                }
            }
        }
        impl DexscrBoost {
            pub fn amount<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<f64>>,
                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 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 header<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.header = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for header: {}", e)
                    });
                self
            }
            pub fn icon<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                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::option::Option<::serde_json::Value>>,
                T::Error: ::std::fmt::Display,
            {
                self.links = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for links: {}", e)
                    });
                self
            }
            pub fn open_graph<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.open_graph = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for open_graph: {}", 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_amount<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<f64>,
                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 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<DexscrBoost> for super::DexscrBoost {
            type Error = super::error::ConversionError;
            fn try_from(
                value: DexscrBoost,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    amount: value.amount?,
                    chain: value.chain?,
                    description: value.description?,
                    header: value.header?,
                    icon: value.icon?,
                    links: value.links?,
                    open_graph: value.open_graph?,
                    token_address: value.token_address?,
                    total_amount: value.total_amount?,
                    url: value.url?,
                })
            }
        }
        impl ::std::convert::From<super::DexscrBoost> for DexscrBoost {
            fn from(value: super::DexscrBoost) -> Self {
                Self {
                    amount: Ok(value.amount),
                    chain: Ok(value.chain),
                    description: Ok(value.description),
                    header: Ok(value.header),
                    icon: Ok(value.icon),
                    links: Ok(value.links),
                    open_graph: Ok(value.open_graph),
                    token_address: Ok(value.token_address),
                    total_amount: Ok(value.total_amount),
                    url: Ok(value.url),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct DexscrLinkUpdate {
            chain: ::std::result::Result<::std::string::String, ::std::string::String>,
            description: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            header: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            icon: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            links: ::std::result::Result<
                ::std::option::Option<::serde_json::Value>,
                ::std::string::String,
            >,
            open_graph: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            token_address: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            url: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for DexscrLinkUpdate {
            fn default() -> Self {
                Self {
                    chain: Err("no value supplied for chain".to_string()),
                    description: Ok(Default::default()),
                    header: Ok(Default::default()),
                    icon: Ok(Default::default()),
                    links: Ok(Default::default()),
                    open_graph: Ok(Default::default()),
                    token_address: Err(
                        "no value supplied for token_address".to_string(),
                    ),
                    url: Ok(Default::default()),
                }
            }
        }
        impl DexscrLinkUpdate {
            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 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 header<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.header = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for header: {}", e)
                    });
                self
            }
            pub fn icon<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                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::option::Option<::serde_json::Value>>,
                T::Error: ::std::fmt::Display,
            {
                self.links = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for links: {}", e)
                    });
                self
            }
            pub fn open_graph<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.open_graph = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for open_graph: {}", 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 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<DexscrLinkUpdate> for super::DexscrLinkUpdate {
            type Error = super::error::ConversionError;
            fn try_from(
                value: DexscrLinkUpdate,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    chain: value.chain?,
                    description: value.description?,
                    header: value.header?,
                    icon: value.icon?,
                    links: value.links?,
                    open_graph: value.open_graph?,
                    token_address: value.token_address?,
                    url: value.url?,
                })
            }
        }
        impl ::std::convert::From<super::DexscrLinkUpdate> for DexscrLinkUpdate {
            fn from(value: super::DexscrLinkUpdate) -> Self {
                Self {
                    chain: Ok(value.chain),
                    description: Ok(value.description),
                    header: Ok(value.header),
                    icon: Ok(value.icon),
                    links: Ok(value.links),
                    open_graph: Ok(value.open_graph),
                    token_address: Ok(value.token_address),
                    url: Ok(value.url),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct DexscrTokenInfo {
            ad: ::std::result::Result<
                ::std::option::Option<super::DexscrAd>,
                ::std::string::String,
            >,
            boost: ::std::result::Result<
                ::std::option::Option<super::DexscrBoost>,
                ::std::string::String,
            >,
            chain: ::std::result::Result<::std::string::String, ::std::string::String>,
            link_update: ::std::result::Result<
                ::std::option::Option<super::DexscrLinkUpdate>,
                ::std::string::String,
            >,
            token_address: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for DexscrTokenInfo {
            fn default() -> Self {
                Self {
                    ad: Ok(Default::default()),
                    boost: Ok(Default::default()),
                    chain: Err("no value supplied for chain".to_string()),
                    link_update: Ok(Default::default()),
                    token_address: Err("no value supplied for token_address".to_string()),
                }
            }
        }
        impl DexscrTokenInfo {
            pub fn ad<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<super::DexscrAd>>,
                T::Error: ::std::fmt::Display,
            {
                self.ad = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for ad: {}", e)
                    });
                self
            }
            pub fn boost<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<super::DexscrBoost>>,
                T::Error: ::std::fmt::Display,
            {
                self.boost = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for boost: {}", 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 link_update<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<
                    ::std::option::Option<super::DexscrLinkUpdate>,
                >,
                T::Error: ::std::fmt::Display,
            {
                self.link_update = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for link_update: {}", 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<DexscrTokenInfo> for super::DexscrTokenInfo {
            type Error = super::error::ConversionError;
            fn try_from(
                value: DexscrTokenInfo,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    ad: value.ad?,
                    boost: value.boost?,
                    chain: value.chain?,
                    link_update: value.link_update?,
                    token_address: value.token_address?,
                })
            }
        }
        impl ::std::convert::From<super::DexscrTokenInfo> for DexscrTokenInfo {
            fn from(value: super::DexscrTokenInfo) -> Self {
                Self {
                    ad: Ok(value.ad),
                    boost: Ok(value.boost),
                    chain: Ok(value.chain),
                    link_update: Ok(value.link_update),
                    token_address: Ok(value.token_address),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct DexscrTrendingMeta {
            description: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            icon_type: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            icon_value: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            liquidity: ::std::result::Result<
                ::std::option::Option<f64>,
                ::std::string::String,
            >,
            market_cap: ::std::result::Result<
                ::std::option::Option<f64>,
                ::std::string::String,
            >,
            market_cap_change: ::std::result::Result<
                ::std::option::Option<::serde_json::Value>,
                ::std::string::String,
            >,
            name: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            slug: ::std::result::Result<::std::string::String, ::std::string::String>,
            token_count: ::std::result::Result<
                ::std::option::Option<i64>,
                ::std::string::String,
            >,
            volume: ::std::result::Result<
                ::std::option::Option<f64>,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for DexscrTrendingMeta {
            fn default() -> Self {
                Self {
                    description: Ok(Default::default()),
                    icon_type: Ok(Default::default()),
                    icon_value: Ok(Default::default()),
                    liquidity: Ok(Default::default()),
                    market_cap: Ok(Default::default()),
                    market_cap_change: Ok(Default::default()),
                    name: Ok(Default::default()),
                    slug: Err("no value supplied for slug".to_string()),
                    token_count: Ok(Default::default()),
                    volume: Ok(Default::default()),
                }
            }
        }
        impl DexscrTrendingMeta {
            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 icon_type<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.icon_type = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for icon_type: {}", e)
                    });
                self
            }
            pub fn icon_value<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.icon_value = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for icon_value: {}", e)
                    });
                self
            }
            pub fn liquidity<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<f64>>,
                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_cap<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<f64>>,
                T::Error: ::std::fmt::Display,
            {
                self.market_cap = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for market_cap: {}", e)
                    });
                self
            }
            pub fn market_cap_change<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::serde_json::Value>>,
                T::Error: ::std::fmt::Display,
            {
                self.market_cap_change = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for market_cap_change: {}",
                            e
                        )
                    });
                self
            }
            pub fn name<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::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 slug<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.slug = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for slug: {}", 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 volume<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<f64>>,
                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<DexscrTrendingMeta> for super::DexscrTrendingMeta {
            type Error = super::error::ConversionError;
            fn try_from(
                value: DexscrTrendingMeta,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    description: value.description?,
                    icon_type: value.icon_type?,
                    icon_value: value.icon_value?,
                    liquidity: value.liquidity?,
                    market_cap: value.market_cap?,
                    market_cap_change: value.market_cap_change?,
                    name: value.name?,
                    slug: value.slug?,
                    token_count: value.token_count?,
                    volume: value.volume?,
                })
            }
        }
        impl ::std::convert::From<super::DexscrTrendingMeta> for DexscrTrendingMeta {
            fn from(value: super::DexscrTrendingMeta) -> Self {
                Self {
                    description: Ok(value.description),
                    icon_type: Ok(value.icon_type),
                    icon_value: Ok(value.icon_value),
                    liquidity: Ok(value.liquidity),
                    market_cap: Ok(value.market_cap),
                    market_cap_change: Ok(value.market_cap_change),
                    name: Ok(value.name),
                    slug: Ok(value.slug),
                    token_count: Ok(value.token_count),
                    volume: Ok(value.volume),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct EndpointListResponse {
            data: ::std::result::Result<
                ::std::vec::Vec<super::WebhookEndpoint>,
                ::std::string::String,
            >,
            done: ::std::result::Result<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: Err("no value supplied for data".to_string()),
                    done: Err("no value supplied for done".to_string()),
                    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::WebhookEndpoint>>,
                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<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<bool, ::std::string::String>,
        }
        impl ::std::default::Default for EndpointOperationResponse {
            fn default() -> Self {
                Self {
                    success: Err("no value supplied for success".to_string()),
                }
            }
        }
        impl EndpointOperationResponse {
            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<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 EndpointSecretResponse {
            secret: ::std::result::Result<::std::string::String, ::std::string::String>,
        }
        impl ::std::default::Default for EndpointSecretResponse {
            fn default() -> Self {
                Self {
                    secret: Err("no value supplied for secret".to_string()),
                }
            }
        }
        impl EndpointSecretResponse {
            pub fn secret<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::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 ErrorDetail {
            code: ::std::result::Result<i32, ::std::string::String>,
            details: ::std::result::Result<
                ::std::vec::Vec<super::ErrorField>,
                ::std::string::String,
            >,
            message: ::std::result::Result<::std::string::String, ::std::string::String>,
        }
        impl ::std::default::Default for ErrorDetail {
            fn default() -> Self {
                Self {
                    code: Err("no value supplied for code".to_string()),
                    details: Ok(Default::default()),
                    message: Err("no value supplied for message".to_string()),
                }
            }
        }
        impl ErrorDetail {
            pub fn code<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<i32>,
                T::Error: ::std::fmt::Display,
            {
                self.code = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for code: {}", e)
                    });
                self
            }
            pub fn details<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::vec::Vec<super::ErrorField>>,
                T::Error: ::std::fmt::Display,
            {
                self.details = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for details: {}", e)
                    });
                self
            }
            pub fn message<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.message = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for message: {}", e)
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<ErrorDetail> for super::ErrorDetail {
            type Error = super::error::ConversionError;
            fn try_from(
                value: ErrorDetail,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    code: value.code?,
                    details: value.details?,
                    message: value.message?,
                })
            }
        }
        impl ::std::convert::From<super::ErrorDetail> for ErrorDetail {
            fn from(value: super::ErrorDetail) -> Self {
                Self {
                    code: Ok(value.code),
                    details: Ok(value.details),
                    message: Ok(value.message),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct ErrorField {
            field: ::std::result::Result<::std::string::String, ::std::string::String>,
            message: ::std::result::Result<::std::string::String, ::std::string::String>,
        }
        impl ::std::default::Default for ErrorField {
            fn default() -> Self {
                Self {
                    field: Err("no value supplied for field".to_string()),
                    message: Err("no value supplied for message".to_string()),
                }
            }
        }
        impl ErrorField {
            pub fn field<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.field = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for field: {}", e)
                    });
                self
            }
            pub fn message<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.message = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for message: {}", e)
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<ErrorField> for super::ErrorField {
            type Error = super::error::ConversionError;
            fn try_from(
                value: ErrorField,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    field: value.field?,
                    message: value.message?,
                })
            }
        }
        impl ::std::convert::From<super::ErrorField> for ErrorField {
            fn from(value: super::ErrorField) -> Self {
                Self {
                    field: Ok(value.field),
                    message: Ok(value.message),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct ErrorResponse {
            error: ::std::result::Result<super::ErrorDetail, ::std::string::String>,
        }
        impl ::std::default::Default for ErrorResponse {
            fn default() -> Self {
                Self {
                    error: Err("no value supplied for error".to_string()),
                }
            }
        }
        impl ErrorResponse {
            pub fn error<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<super::ErrorDetail>,
                T::Error: ::std::fmt::Display,
            {
                self.error = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for error: {}", e)
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<ErrorResponse> for super::ErrorResponse {
            type Error = super::error::ConversionError;
            fn try_from(
                value: ErrorResponse,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self { error: value.error? })
            }
        }
        impl ::std::convert::From<super::ErrorResponse> for ErrorResponse {
            fn from(value: super::ErrorResponse) -> Self {
                Self { error: Ok(value.error) }
            }
        }
        #[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::string::String, ::std::string::String>,
            operator: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            value: ::std::result::Result<::std::string::String, ::std::string::String>,
        }
        impl ::std::default::Default for FilterCondition {
            fn default() -> Self {
                Self {
                    field: Err("no value supplied for field".to_string()),
                    operator: Err("no value supplied for operator".to_string()),
                    value: Err("no value supplied for value".to_string()),
                }
            }
        }
        impl FilterCondition {
            pub fn field<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.field = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for field: {}", e)
                    });
                self
            }
            pub fn operator<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.operator = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for operator: {}", 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<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?,
                    operator: value.operator?,
                    value: value.value?,
                })
            }
        }
        impl ::std::convert::From<super::FilterCondition> for FilterCondition {
            fn from(value: super::FilterCondition) -> Self {
                Self {
                    field: Ok(value.field),
                    operator: Ok(value.operator),
                    value: Ok(value.value),
                }
            }
        }
        #[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 GetMarketDataMultiResponseValue {
            ath_market_cap_in_usd: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            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,
            >,
            circulating_supply: ::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,
            >,
            creators_holdings_ratio: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            creators_total_holders: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            creators_total_holdings: ::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,
            >,
            fdv_in_sol: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            fdv_in_usd: ::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::option::Option<::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::option::Option<::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,
            >,
            phishing_holdings_ratio: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            phishing_total_holders: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            phishing_total_holdings: ::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::option::Option<::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,
            >,
            rat_holdings_ratio: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            rat_total_holders: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            rat_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,
            >,
            smart_holdings_ratio: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            smart_total_holders: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            smart_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::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            total_tvl_in_sol: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            total_tvl_in_usd: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for GetMarketDataMultiResponseValue {
            fn default() -> Self {
                Self {
                    ath_market_cap_in_usd: Ok(Default::default()),
                    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()),
                    circulating_supply: Ok(Default::default()),
                    completion_ratio: Ok(Default::default()),
                    creators_holdings_ratio: Ok(Default::default()),
                    creators_total_holders: Ok(Default::default()),
                    creators_total_holdings: Ok(Default::default()),
                    dev_holdings_ratio: Ok(Default::default()),
                    dev_total_holders: Ok(Default::default()),
                    dev_total_holdings: Ok(Default::default()),
                    fdv_in_sol: Ok(Default::default()),
                    fdv_in_usd: Ok(Default::default()),
                    fresh_holdings_ratio: Ok(Default::default()),
                    fresh_total_holders: Ok(Default::default()),
                    fresh_total_holdings: Ok(Default::default()),
                    holders: Ok(Default::default()),
                    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: Ok(Default::default()),
                    max_pool_tvl_in_sol: Ok(Default::default()),
                    max_pool_tvl_in_usd: Ok(Default::default()),
                    phishing_holdings_ratio: Ok(Default::default()),
                    phishing_total_holders: Ok(Default::default()),
                    phishing_total_holdings: Ok(Default::default()),
                    price_in_sol: Ok(Default::default()),
                    price_in_usd: Ok(Default::default()),
                    pro_holdings_ratio: Ok(Default::default()),
                    pro_total_holders: Ok(Default::default()),
                    pro_total_holdings: Ok(Default::default()),
                    rat_holdings_ratio: Ok(Default::default()),
                    rat_total_holders: Ok(Default::default()),
                    rat_total_holdings: Ok(Default::default()),
                    sandwish_holdings_ratio: Ok(Default::default()),
                    sandwish_total_holders: Ok(Default::default()),
                    sandwish_total_holdings: Ok(Default::default()),
                    smart_holdings_ratio: Ok(Default::default()),
                    smart_total_holders: Ok(Default::default()),
                    smart_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: Ok(Default::default()),
                    total_tvl_in_sol: Ok(Default::default()),
                    total_tvl_in_usd: Ok(Default::default()),
                }
            }
        }
        impl GetMarketDataMultiResponseValue {
            pub fn ath_market_cap_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.ath_market_cap_in_usd = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for ath_market_cap_in_usd: {}",
                            e
                        )
                    });
                self
            }
            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 circulating_supply<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.circulating_supply = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for circulating_supply: {}",
                            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 creators_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.creators_holdings_ratio = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for creators_holdings_ratio: {}",
                            e
                        )
                    });
                self
            }
            pub fn creators_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.creators_total_holders = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for creators_total_holders: {}",
                            e
                        )
                    });
                self
            }
            pub fn creators_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.creators_total_holdings = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for creators_total_holdings: {}",
                            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 fdv_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.fdv_in_sol = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for fdv_in_sol: {}", e)
                    });
                self
            }
            pub fn fdv_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.fdv_in_usd = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for fdv_in_usd: {}", 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::option::Option<::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::option::Option<::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 phishing_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.phishing_holdings_ratio = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for phishing_holdings_ratio: {}",
                            e
                        )
                    });
                self
            }
            pub fn phishing_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.phishing_total_holders = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for phishing_total_holders: {}",
                            e
                        )
                    });
                self
            }
            pub fn phishing_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.phishing_total_holdings = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for phishing_total_holdings: {}",
                            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::option::Option<::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 rat_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.rat_holdings_ratio = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for rat_holdings_ratio: {}",
                            e
                        )
                    });
                self
            }
            pub fn rat_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.rat_total_holders = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for rat_total_holders: {}",
                            e
                        )
                    });
                self
            }
            pub fn rat_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.rat_total_holdings = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for rat_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 smart_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.smart_holdings_ratio = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for smart_holdings_ratio: {}",
                            e
                        )
                    });
                self
            }
            pub fn smart_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.smart_total_holders = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for smart_total_holders: {}",
                            e
                        )
                    });
                self
            }
            pub fn smart_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.smart_total_holdings = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for smart_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::option::Option<::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::option::Option<::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::option::Option<::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<GetMarketDataMultiResponseValue>
        for super::GetMarketDataMultiResponseValue {
            type Error = super::error::ConversionError;
            fn try_from(
                value: GetMarketDataMultiResponseValue,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    ath_market_cap_in_usd: value.ath_market_cap_in_usd?,
                    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?,
                    circulating_supply: value.circulating_supply?,
                    completion_ratio: value.completion_ratio?,
                    creators_holdings_ratio: value.creators_holdings_ratio?,
                    creators_total_holders: value.creators_total_holders?,
                    creators_total_holdings: value.creators_total_holdings?,
                    dev_holdings_ratio: value.dev_holdings_ratio?,
                    dev_total_holders: value.dev_total_holders?,
                    dev_total_holdings: value.dev_total_holdings?,
                    fdv_in_sol: value.fdv_in_sol?,
                    fdv_in_usd: value.fdv_in_usd?,
                    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?,
                    phishing_holdings_ratio: value.phishing_holdings_ratio?,
                    phishing_total_holders: value.phishing_total_holders?,
                    phishing_total_holdings: value.phishing_total_holdings?,
                    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?,
                    rat_holdings_ratio: value.rat_holdings_ratio?,
                    rat_total_holders: value.rat_total_holders?,
                    rat_total_holdings: value.rat_total_holdings?,
                    sandwish_holdings_ratio: value.sandwish_holdings_ratio?,
                    sandwish_total_holders: value.sandwish_total_holders?,
                    sandwish_total_holdings: value.sandwish_total_holdings?,
                    smart_holdings_ratio: value.smart_holdings_ratio?,
                    smart_total_holders: value.smart_total_holders?,
                    smart_total_holdings: value.smart_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::GetMarketDataMultiResponseValue>
        for GetMarketDataMultiResponseValue {
            fn from(value: super::GetMarketDataMultiResponseValue) -> Self {
                Self {
                    ath_market_cap_in_usd: Ok(value.ath_market_cap_in_usd),
                    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),
                    circulating_supply: Ok(value.circulating_supply),
                    completion_ratio: Ok(value.completion_ratio),
                    creators_holdings_ratio: Ok(value.creators_holdings_ratio),
                    creators_total_holders: Ok(value.creators_total_holders),
                    creators_total_holdings: Ok(value.creators_total_holdings),
                    dev_holdings_ratio: Ok(value.dev_holdings_ratio),
                    dev_total_holders: Ok(value.dev_total_holders),
                    dev_total_holdings: Ok(value.dev_total_holdings),
                    fdv_in_sol: Ok(value.fdv_in_sol),
                    fdv_in_usd: Ok(value.fdv_in_usd),
                    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),
                    phishing_holdings_ratio: Ok(value.phishing_holdings_ratio),
                    phishing_total_holders: Ok(value.phishing_total_holders),
                    phishing_total_holdings: Ok(value.phishing_total_holdings),
                    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),
                    rat_holdings_ratio: Ok(value.rat_holdings_ratio),
                    rat_total_holders: Ok(value.rat_total_holders),
                    rat_total_holdings: Ok(value.rat_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),
                    smart_holdings_ratio: Ok(value.smart_holdings_ratio),
                    smart_total_holders: Ok(value.smart_total_holders),
                    smart_total_holdings: Ok(value.smart_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 GetMetadataMultiResponseValue {
            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<
                ::std::string::String,
                ::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::TokenExtra>,
                ::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::TokenSocialMedias>,
                ::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::TokenCreator>,
                ::std::string::String,
            >,
            updated_at: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            uri: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for GetMetadataMultiResponseValue {
            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()),
                    updated_at: Ok(Default::default()),
                    uri: Ok(Default::default()),
                }
            }
        }
        impl GetMetadataMultiResponseValue {
            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<::std::string::String>,
                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::TokenExtra>>,
                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::TokenSocialMedias>,
                >,
                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::TokenCreator>>,
                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 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 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<GetMetadataMultiResponseValue>
        for super::GetMetadataMultiResponseValue {
            type Error = super::error::ConversionError;
            fn try_from(
                value: GetMetadataMultiResponseValue,
            ) -> ::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?,
                    updated_at: value.updated_at?,
                    uri: value.uri?,
                })
            }
        }
        impl ::std::convert::From<super::GetMetadataMultiResponseValue>
        for GetMetadataMultiResponseValue {
            fn from(value: super::GetMetadataMultiResponseValue) -> 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),
                    updated_at: Ok(value.updated_at),
                    uri: Ok(value.uri),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct GetStatsMultiResponseValue {
            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 GetStatsMultiResponseValue {
            fn default() -> Self {
                Self {
                    address: Err("no value supplied for address".to_string()),
                    periods: Err("no value supplied for periods".to_string()),
                }
            }
        }
        impl GetStatsMultiResponseValue {
            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<GetStatsMultiResponseValue>
        for super::GetStatsMultiResponseValue {
            type Error = super::error::ConversionError;
            fn try_from(
                value: GetStatsMultiResponseValue,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    address: value.address?,
                    periods: value.periods?,
                })
            }
        }
        impl ::std::convert::From<super::GetStatsMultiResponseValue>
        for GetStatsMultiResponseValue {
            fn from(value: super::GetStatsMultiResponseValue) -> Self {
                Self {
                    address: Ok(value.address),
                    periods: Ok(value.periods),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct GoPlusSecurityInfo {
            available: ::std::result::Result<bool, ::std::string::String>,
            buy_tax: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            chain_supported: ::std::result::Result<
                ::std::option::Option<bool>,
                ::std::string::String,
            >,
            holder_count: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            is_blacklisted: ::std::result::Result<
                ::std::option::Option<bool>,
                ::std::string::String,
            >,
            is_freezable: ::std::result::Result<
                ::std::option::Option<bool>,
                ::std::string::String,
            >,
            is_honeypot: ::std::result::Result<
                ::std::option::Option<bool>,
                ::std::string::String,
            >,
            is_mintable: ::std::result::Result<
                ::std::option::Option<bool>,
                ::std::string::String,
            >,
            is_open_source: ::std::result::Result<
                ::std::option::Option<bool>,
                ::std::string::String,
            >,
            is_proxy: ::std::result::Result<
                ::std::option::Option<bool>,
                ::std::string::String,
            >,
            is_renounced: ::std::result::Result<
                ::std::option::Option<bool>,
                ::std::string::String,
            >,
            last_refreshed_at: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            lp_holder_count: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            owner_address: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            raw: ::std::result::Result<
                ::std::option::Option<::serde_json::Value>,
                ::std::string::String,
            >,
            sell_tax: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            total_supply: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for GoPlusSecurityInfo {
            fn default() -> Self {
                Self {
                    available: Err("no value supplied for available".to_string()),
                    buy_tax: Ok(Default::default()),
                    chain_supported: Ok(Default::default()),
                    holder_count: Ok(Default::default()),
                    is_blacklisted: Ok(Default::default()),
                    is_freezable: Ok(Default::default()),
                    is_honeypot: Ok(Default::default()),
                    is_mintable: Ok(Default::default()),
                    is_open_source: Ok(Default::default()),
                    is_proxy: Ok(Default::default()),
                    is_renounced: Ok(Default::default()),
                    last_refreshed_at: Ok(Default::default()),
                    lp_holder_count: Ok(Default::default()),
                    owner_address: Ok(Default::default()),
                    raw: Ok(Default::default()),
                    sell_tax: Ok(Default::default()),
                    total_supply: Ok(Default::default()),
                }
            }
        }
        impl GoPlusSecurityInfo {
            pub fn available<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<bool>,
                T::Error: ::std::fmt::Display,
            {
                self.available = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for available: {}", e)
                    });
                self
            }
            pub fn buy_tax<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.buy_tax = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for buy_tax: {}", e)
                    });
                self
            }
            pub fn chain_supported<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<bool>>,
                T::Error: ::std::fmt::Display,
            {
                self.chain_supported = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for chain_supported: {}", e
                        )
                    });
                self
            }
            pub fn holder_count<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.holder_count = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for holder_count: {}", e
                        )
                    });
                self
            }
            pub fn is_blacklisted<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<bool>>,
                T::Error: ::std::fmt::Display,
            {
                self.is_blacklisted = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for is_blacklisted: {}", e
                        )
                    });
                self
            }
            pub fn is_freezable<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<bool>>,
                T::Error: ::std::fmt::Display,
            {
                self.is_freezable = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for is_freezable: {}", e
                        )
                    });
                self
            }
            pub fn is_honeypot<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<bool>>,
                T::Error: ::std::fmt::Display,
            {
                self.is_honeypot = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for is_honeypot: {}", e)
                    });
                self
            }
            pub fn is_mintable<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<bool>>,
                T::Error: ::std::fmt::Display,
            {
                self.is_mintable = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for is_mintable: {}", e)
                    });
                self
            }
            pub fn is_open_source<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<bool>>,
                T::Error: ::std::fmt::Display,
            {
                self.is_open_source = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for is_open_source: {}", e
                        )
                    });
                self
            }
            pub fn is_proxy<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<bool>>,
                T::Error: ::std::fmt::Display,
            {
                self.is_proxy = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for is_proxy: {}", e)
                    });
                self
            }
            pub fn is_renounced<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<bool>>,
                T::Error: ::std::fmt::Display,
            {
                self.is_renounced = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for is_renounced: {}", e
                        )
                    });
                self
            }
            pub fn last_refreshed_at<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.last_refreshed_at = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for last_refreshed_at: {}",
                            e
                        )
                    });
                self
            }
            pub fn lp_holder_count<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.lp_holder_count = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for lp_holder_count: {}", e
                        )
                    });
                self
            }
            pub fn owner_address<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.owner_address = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for owner_address: {}", e
                        )
                    });
                self
            }
            pub fn raw<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::serde_json::Value>>,
                T::Error: ::std::fmt::Display,
            {
                self.raw = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for raw: {}", e)
                    });
                self
            }
            pub fn sell_tax<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.sell_tax = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for sell_tax: {}", e)
                    });
                self
            }
            pub fn total_supply<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::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
            }
        }
        impl ::std::convert::TryFrom<GoPlusSecurityInfo> for super::GoPlusSecurityInfo {
            type Error = super::error::ConversionError;
            fn try_from(
                value: GoPlusSecurityInfo,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    available: value.available?,
                    buy_tax: value.buy_tax?,
                    chain_supported: value.chain_supported?,
                    holder_count: value.holder_count?,
                    is_blacklisted: value.is_blacklisted?,
                    is_freezable: value.is_freezable?,
                    is_honeypot: value.is_honeypot?,
                    is_mintable: value.is_mintable?,
                    is_open_source: value.is_open_source?,
                    is_proxy: value.is_proxy?,
                    is_renounced: value.is_renounced?,
                    last_refreshed_at: value.last_refreshed_at?,
                    lp_holder_count: value.lp_holder_count?,
                    owner_address: value.owner_address?,
                    raw: value.raw?,
                    sell_tax: value.sell_tax?,
                    total_supply: value.total_supply?,
                })
            }
        }
        impl ::std::convert::From<super::GoPlusSecurityInfo> for GoPlusSecurityInfo {
            fn from(value: super::GoPlusSecurityInfo) -> Self {
                Self {
                    available: Ok(value.available),
                    buy_tax: Ok(value.buy_tax),
                    chain_supported: Ok(value.chain_supported),
                    holder_count: Ok(value.holder_count),
                    is_blacklisted: Ok(value.is_blacklisted),
                    is_freezable: Ok(value.is_freezable),
                    is_honeypot: Ok(value.is_honeypot),
                    is_mintable: Ok(value.is_mintable),
                    is_open_source: Ok(value.is_open_source),
                    is_proxy: Ok(value.is_proxy),
                    is_renounced: Ok(value.is_renounced),
                    last_refreshed_at: Ok(value.last_refreshed_at),
                    lp_holder_count: Ok(value.lp_holder_count),
                    owner_address: Ok(value.owner_address),
                    raw: Ok(value.raw),
                    sell_tax: Ok(value.sell_tax),
                    total_supply: Ok(value.total_supply),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct HoneypotIsSecurityInfo {
            available: ::std::result::Result<bool, ::std::string::String>,
            average_tax: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            buy_tax: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            can_not_sell: ::std::result::Result<
                ::std::option::Option<i32>,
                ::std::string::String,
            >,
            can_sell: ::std::result::Result<
                ::std::option::Option<i32>,
                ::std::string::String,
            >,
            chain_supported: ::std::result::Result<
                ::std::option::Option<bool>,
                ::std::string::String,
            >,
            high_tax: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            honeypot_result: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            is_honeypot: ::std::result::Result<
                ::std::option::Option<bool>,
                ::std::string::String,
            >,
            is_open_source: ::std::result::Result<
                ::std::option::Option<bool>,
                ::std::string::String,
            >,
            is_renounced: ::std::result::Result<
                ::std::option::Option<bool>,
                ::std::string::String,
            >,
            last_refreshed_at: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            raw: ::std::result::Result<
                ::std::option::Option<::serde_json::Value>,
                ::std::string::String,
            >,
            sell_tax: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for HoneypotIsSecurityInfo {
            fn default() -> Self {
                Self {
                    available: Err("no value supplied for available".to_string()),
                    average_tax: Ok(Default::default()),
                    buy_tax: Ok(Default::default()),
                    can_not_sell: Ok(Default::default()),
                    can_sell: Ok(Default::default()),
                    chain_supported: Ok(Default::default()),
                    high_tax: Ok(Default::default()),
                    honeypot_result: Ok(Default::default()),
                    is_honeypot: Ok(Default::default()),
                    is_open_source: Ok(Default::default()),
                    is_renounced: Ok(Default::default()),
                    last_refreshed_at: Ok(Default::default()),
                    raw: Ok(Default::default()),
                    sell_tax: Ok(Default::default()),
                }
            }
        }
        impl HoneypotIsSecurityInfo {
            pub fn available<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<bool>,
                T::Error: ::std::fmt::Display,
            {
                self.available = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for available: {}", e)
                    });
                self
            }
            pub fn average_tax<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.average_tax = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for average_tax: {}", e)
                    });
                self
            }
            pub fn buy_tax<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.buy_tax = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for buy_tax: {}", e)
                    });
                self
            }
            pub fn can_not_sell<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<i32>>,
                T::Error: ::std::fmt::Display,
            {
                self.can_not_sell = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for can_not_sell: {}", e
                        )
                    });
                self
            }
            pub fn can_sell<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<i32>>,
                T::Error: ::std::fmt::Display,
            {
                self.can_sell = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for can_sell: {}", e)
                    });
                self
            }
            pub fn chain_supported<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<bool>>,
                T::Error: ::std::fmt::Display,
            {
                self.chain_supported = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for chain_supported: {}", e
                        )
                    });
                self
            }
            pub fn high_tax<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.high_tax = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for high_tax: {}", e)
                    });
                self
            }
            pub fn honeypot_result<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.honeypot_result = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for honeypot_result: {}", e
                        )
                    });
                self
            }
            pub fn is_honeypot<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<bool>>,
                T::Error: ::std::fmt::Display,
            {
                self.is_honeypot = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for is_honeypot: {}", e)
                    });
                self
            }
            pub fn is_open_source<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<bool>>,
                T::Error: ::std::fmt::Display,
            {
                self.is_open_source = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for is_open_source: {}", e
                        )
                    });
                self
            }
            pub fn is_renounced<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<bool>>,
                T::Error: ::std::fmt::Display,
            {
                self.is_renounced = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for is_renounced: {}", e
                        )
                    });
                self
            }
            pub fn last_refreshed_at<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.last_refreshed_at = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for last_refreshed_at: {}",
                            e
                        )
                    });
                self
            }
            pub fn raw<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::serde_json::Value>>,
                T::Error: ::std::fmt::Display,
            {
                self.raw = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for raw: {}", e)
                    });
                self
            }
            pub fn sell_tax<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.sell_tax = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for sell_tax: {}", e)
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<HoneypotIsSecurityInfo>
        for super::HoneypotIsSecurityInfo {
            type Error = super::error::ConversionError;
            fn try_from(
                value: HoneypotIsSecurityInfo,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    available: value.available?,
                    average_tax: value.average_tax?,
                    buy_tax: value.buy_tax?,
                    can_not_sell: value.can_not_sell?,
                    can_sell: value.can_sell?,
                    chain_supported: value.chain_supported?,
                    high_tax: value.high_tax?,
                    honeypot_result: value.honeypot_result?,
                    is_honeypot: value.is_honeypot?,
                    is_open_source: value.is_open_source?,
                    is_renounced: value.is_renounced?,
                    last_refreshed_at: value.last_refreshed_at?,
                    raw: value.raw?,
                    sell_tax: value.sell_tax?,
                })
            }
        }
        impl ::std::convert::From<super::HoneypotIsSecurityInfo>
        for HoneypotIsSecurityInfo {
            fn from(value: super::HoneypotIsSecurityInfo) -> Self {
                Self {
                    available: Ok(value.available),
                    average_tax: Ok(value.average_tax),
                    buy_tax: Ok(value.buy_tax),
                    can_not_sell: Ok(value.can_not_sell),
                    can_sell: Ok(value.can_sell),
                    chain_supported: Ok(value.chain_supported),
                    high_tax: Ok(value.high_tax),
                    honeypot_result: Ok(value.honeypot_result),
                    is_honeypot: Ok(value.is_honeypot),
                    is_open_source: Ok(value.is_open_source),
                    is_renounced: Ok(value.is_renounced),
                    last_refreshed_at: Ok(value.last_refreshed_at),
                    raw: Ok(value.raw),
                    sell_tax: Ok(value.sell_tax),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct IpfsUploadResponse {
            cid: ::std::result::Result<::std::string::String, ::std::string::String>,
            name: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            size: ::std::result::Result<
                ::std::option::Option<i64>,
                ::std::string::String,
            >,
            url: ::std::result::Result<::std::string::String, ::std::string::String>,
        }
        impl ::std::default::Default for IpfsUploadResponse {
            fn default() -> Self {
                Self {
                    cid: Err("no value supplied for cid".to_string()),
                    name: Ok(Default::default()),
                    size: Ok(Default::default()),
                    url: Err("no value supplied for url".to_string()),
                }
            }
        }
        impl IpfsUploadResponse {
            pub fn cid<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.cid = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for cid: {}", e)
                    });
                self
            }
            pub fn name<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::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 size<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<i64>>,
                T::Error: ::std::fmt::Display,
            {
                self.size = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for size: {}", 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<IpfsUploadResponse> for super::IpfsUploadResponse {
            type Error = super::error::ConversionError;
            fn try_from(
                value: IpfsUploadResponse,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    cid: value.cid?,
                    name: value.name?,
                    size: value.size?,
                    url: value.url?,
                })
            }
        }
        impl ::std::convert::From<super::IpfsUploadResponse> for IpfsUploadResponse {
            fn from(value: super::IpfsUploadResponse) -> Self {
                Self {
                    cid: Ok(value.cid),
                    name: Ok(value.name),
                    size: Ok(value.size),
                    url: Ok(value.url),
                }
            }
        }
        #[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 KytAddressExposure {
            category: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            direction: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            exposure_type: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            value: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for KytAddressExposure {
            fn default() -> Self {
                Self {
                    category: Ok(Default::default()),
                    direction: Ok(Default::default()),
                    exposure_type: Ok(Default::default()),
                    value: Ok(Default::default()),
                }
            }
        }
        impl KytAddressExposure {
            pub fn category<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::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::option::Option<::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::option::Option<::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::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<KytAddressExposure> for super::KytAddressExposure {
            type Error = super::error::ConversionError;
            fn try_from(
                value: KytAddressExposure,
            ) -> ::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::KytAddressExposure> for KytAddressExposure {
            fn from(value: super::KytAddressExposure) -> 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 KytAddressIdentification {
            address_name: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            category_id: ::std::result::Result<
                ::std::option::Option<i64>,
                ::std::string::String,
            >,
            description: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for KytAddressIdentification {
            fn default() -> Self {
                Self {
                    address_name: Ok(Default::default()),
                    category_id: Ok(Default::default()),
                    description: Ok(Default::default()),
                }
            }
        }
        impl KytAddressIdentification {
            pub fn address_name<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::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<::std::option::Option<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::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
            }
        }
        impl ::std::convert::TryFrom<KytAddressIdentification>
        for super::KytAddressIdentification {
            type Error = super::error::ConversionError;
            fn try_from(
                value: KytAddressIdentification,
            ) -> ::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::KytAddressIdentification>
        for KytAddressIdentification {
            fn from(value: super::KytAddressIdentification) -> Self {
                Self {
                    address_name: Ok(value.address_name),
                    category_id: Ok(value.category_id),
                    description: Ok(value.description),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct KytAddressRiskResponse {
            address: ::std::result::Result<::std::string::String, ::std::string::String>,
            address_identifications: ::std::result::Result<
                ::std::vec::Vec<::serde_json::Value>,
                ::std::string::String,
            >,
            address_type: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            cluster: ::std::result::Result<
                ::serde_json::Map<::std::string::String, ::serde_json::Value>,
                ::std::string::String,
            >,
            exposures: ::std::result::Result<
                ::std::vec::Vec<super::KytAddressExposure>,
                ::std::string::String,
            >,
            risk: ::std::result::Result<
                ::std::option::Option<::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::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            triggers: ::std::result::Result<
                ::std::vec::Vec<::serde_json::Value>,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for KytAddressRiskResponse {
            fn default() -> Self {
                Self {
                    address: Err("no value supplied for address".to_string()),
                    address_identifications: Ok(Default::default()),
                    address_type: Ok(Default::default()),
                    cluster: Ok(Default::default()),
                    exposures: Ok(Default::default()),
                    risk: Ok(Default::default()),
                    risk_reason: Ok(Default::default()),
                    status: Ok(Default::default()),
                    triggers: Ok(Default::default()),
                }
            }
        }
        impl KytAddressRiskResponse {
            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<::serde_json::Value>>,
                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::option::Option<::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<
                    ::serde_json::Map<::std::string::String, ::serde_json::Value>,
                >,
                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::KytAddressExposure>>,
                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::option::Option<::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::option::Option<::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<::serde_json::Value>>,
                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<KytAddressRiskResponse>
        for super::KytAddressRiskResponse {
            type Error = super::error::ConversionError;
            fn try_from(
                value: KytAddressRiskResponse,
            ) -> ::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::KytAddressRiskResponse>
        for KytAddressRiskResponse {
            fn from(value: super::KytAddressRiskResponse) -> 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 KytAlertDetail {
            alert_amount: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            alert_level: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            category_id: ::std::result::Result<
                ::std::option::Option<i64>,
                ::std::string::String,
            >,
            exposure_type: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            external_id: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            memo: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            service: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for KytAlertDetail {
            fn default() -> Self {
                Self {
                    alert_amount: Ok(Default::default()),
                    alert_level: Ok(Default::default()),
                    category_id: Ok(Default::default()),
                    exposure_type: Ok(Default::default()),
                    external_id: Ok(Default::default()),
                    memo: Ok(Default::default()),
                    service: Ok(Default::default()),
                }
            }
        }
        impl KytAlertDetail {
            pub fn alert_amount<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::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::option::Option<::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<::std::option::Option<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::option::Option<::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::option::Option<::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::option::Option<::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<KytAlertDetail> for super::KytAlertDetail {
            type Error = super::error::ConversionError;
            fn try_from(
                value: KytAlertDetail,
            ) -> ::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::KytAlertDetail> for KytAlertDetail {
            fn from(value: super::KytAlertDetail) -> 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 KytAlertsResponse {
            alerts: ::std::result::Result<
                ::std::vec::Vec<super::KytAlertDetail>,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for KytAlertsResponse {
            fn default() -> Self {
                Self {
                    alerts: Err("no value supplied for alerts".to_string()),
                }
            }
        }
        impl KytAlertsResponse {
            pub fn alerts<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::vec::Vec<super::KytAlertDetail>>,
                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<KytAlertsResponse> for super::KytAlertsResponse {
            type Error = super::error::ConversionError;
            fn try_from(
                value: KytAlertsResponse,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self { alerts: value.alerts? })
            }
        }
        impl ::std::convert::From<super::KytAlertsResponse> for KytAlertsResponse {
            fn from(value: super::KytAlertsResponse) -> Self {
                Self { alerts: Ok(value.alerts) }
            }
        }
        #[derive(Clone, Debug)]
        pub struct KytAlteryaIdentification {
            address: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            chain: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            labels: ::std::result::Result<
                ::std::vec::Vec<::std::string::String>,
                ::std::string::String,
            >,
            object: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            on_chain_activity: ::std::result::Result<
                ::std::option::Option<super::KytOnChainActivity>,
                ::std::string::String,
            >,
            reason: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            risk_level: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            risk_score: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for KytAlteryaIdentification {
            fn default() -> Self {
                Self {
                    address: Ok(Default::default()),
                    chain: Ok(Default::default()),
                    labels: Ok(Default::default()),
                    object: Ok(Default::default()),
                    on_chain_activity: Ok(Default::default()),
                    reason: Ok(Default::default()),
                    risk_level: Ok(Default::default()),
                    risk_score: Ok(Default::default()),
                }
            }
        }
        impl KytAlteryaIdentification {
            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 chain<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::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::option::Option<::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<
                    ::std::option::Option<super::KytOnChainActivity>,
                >,
                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::option::Option<::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::option::Option<::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::option::Option<::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<KytAlteryaIdentification>
        for super::KytAlteryaIdentification {
            type Error = super::error::ConversionError;
            fn try_from(
                value: KytAlteryaIdentification,
            ) -> ::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::KytAlteryaIdentification>
        for KytAlteryaIdentification {
            fn from(value: super::KytAlteryaIdentification) -> 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 KytDirectExposureDetail {
            category_id: ::std::result::Result<
                ::std::option::Option<i64>,
                ::std::string::String,
            >,
            name: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for KytDirectExposureDetail {
            fn default() -> Self {
                Self {
                    category_id: Ok(Default::default()),
                    name: Ok(Default::default()),
                }
            }
        }
        impl KytDirectExposureDetail {
            pub fn category_id<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<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::option::Option<::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<KytDirectExposureDetail>
        for super::KytDirectExposureDetail {
            type Error = super::error::ConversionError;
            fn try_from(
                value: KytDirectExposureDetail,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    category_id: value.category_id?,
                    name: value.name?,
                })
            }
        }
        impl ::std::convert::From<super::KytDirectExposureDetail>
        for KytDirectExposureDetail {
            fn from(value: super::KytDirectExposureDetail) -> Self {
                Self {
                    category_id: Ok(value.category_id),
                    name: Ok(value.name),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct KytDirectExposureResponse {
            direct: ::std::result::Result<
                ::std::option::Option<super::KytDirectExposureDetail>,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for KytDirectExposureResponse {
            fn default() -> Self {
                Self {
                    direct: Ok(Default::default()),
                }
            }
        }
        impl KytDirectExposureResponse {
            pub fn direct<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<
                    ::std::option::Option<super::KytDirectExposureDetail>,
                >,
                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<KytDirectExposureResponse>
        for super::KytDirectExposureResponse {
            type Error = super::error::ConversionError;
            fn try_from(
                value: KytDirectExposureResponse,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self { direct: value.direct? })
            }
        }
        impl ::std::convert::From<super::KytDirectExposureResponse>
        for KytDirectExposureResponse {
            fn from(value: super::KytDirectExposureResponse) -> Self {
                Self { direct: Ok(value.direct) }
            }
        }
        #[derive(Clone, Debug)]
        pub struct KytFraudAssessmentResponse {
            alterya_identifications: ::std::result::Result<
                ::std::vec::Vec<super::KytAlteryaIdentification>,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for KytFraudAssessmentResponse {
            fn default() -> Self {
                Self {
                    alterya_identifications: Ok(Default::default()),
                }
            }
        }
        impl KytFraudAssessmentResponse {
            pub fn alterya_identifications<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<
                    ::std::vec::Vec<super::KytAlteryaIdentification>,
                >,
                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<KytFraudAssessmentResponse>
        for super::KytFraudAssessmentResponse {
            type Error = super::error::ConversionError;
            fn try_from(
                value: KytFraudAssessmentResponse,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    alterya_identifications: value.alterya_identifications?,
                })
            }
        }
        impl ::std::convert::From<super::KytFraudAssessmentResponse>
        for KytFraudAssessmentResponse {
            fn from(value: super::KytFraudAssessmentResponse) -> Self {
                Self {
                    alterya_identifications: Ok(value.alterya_identifications),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct KytNetworkIdentificationOrg {
            name: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for KytNetworkIdentificationOrg {
            fn default() -> Self {
                Self {
                    name: Ok(Default::default()),
                }
            }
        }
        impl KytNetworkIdentificationOrg {
            pub fn name<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::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<KytNetworkIdentificationOrg>
        for super::KytNetworkIdentificationOrg {
            type Error = super::error::ConversionError;
            fn try_from(
                value: KytNetworkIdentificationOrg,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self { name: value.name? })
            }
        }
        impl ::std::convert::From<super::KytNetworkIdentificationOrg>
        for KytNetworkIdentificationOrg {
            fn from(value: super::KytNetworkIdentificationOrg) -> Self {
                Self { name: Ok(value.name) }
            }
        }
        #[derive(Clone, Debug)]
        pub struct KytNetworkIdentificationsResponse {
            count: ::std::result::Result<
                ::std::option::Option<i64>,
                ::std::string::String,
            >,
            network_identification_orgs: ::std::result::Result<
                ::std::vec::Vec<super::KytNetworkIdentificationOrg>,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for KytNetworkIdentificationsResponse {
            fn default() -> Self {
                Self {
                    count: Ok(Default::default()),
                    network_identification_orgs: Ok(Default::default()),
                }
            }
        }
        impl KytNetworkIdentificationsResponse {
            pub fn count<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<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::KytNetworkIdentificationOrg>,
                >,
                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<KytNetworkIdentificationsResponse>
        for super::KytNetworkIdentificationsResponse {
            type Error = super::error::ConversionError;
            fn try_from(
                value: KytNetworkIdentificationsResponse,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    count: value.count?,
                    network_identification_orgs: value.network_identification_orgs?,
                })
            }
        }
        impl ::std::convert::From<super::KytNetworkIdentificationsResponse>
        for KytNetworkIdentificationsResponse {
            fn from(value: super::KytNetworkIdentificationsResponse) -> Self {
                Self {
                    count: Ok(value.count),
                    network_identification_orgs: Ok(value.network_identification_orgs),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct KytOnChainActivity {
            first_transaction_at: ::std::result::Result<
                ::std::option::Option<i64>,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for KytOnChainActivity {
            fn default() -> Self {
                Self {
                    first_transaction_at: Ok(Default::default()),
                }
            }
        }
        impl KytOnChainActivity {
            pub fn first_transaction_at<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<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<KytOnChainActivity> for super::KytOnChainActivity {
            type Error = super::error::ConversionError;
            fn try_from(
                value: KytOnChainActivity,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    first_transaction_at: value.first_transaction_at?,
                })
            }
        }
        impl ::std::convert::From<super::KytOnChainActivity> for KytOnChainActivity {
            fn from(value: super::KytOnChainActivity) -> Self {
                Self {
                    first_transaction_at: Ok(value.first_transaction_at),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct KytRegisterAddressInput {
            address: ::std::result::Result<::std::string::String, ::std::string::String>,
        }
        impl ::std::default::Default for KytRegisterAddressInput {
            fn default() -> Self {
                Self {
                    address: Err("no value supplied for address".to_string()),
                }
            }
        }
        impl KytRegisterAddressInput {
            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<KytRegisterAddressInput>
        for super::KytRegisterAddressInput {
            type Error = super::error::ConversionError;
            fn try_from(
                value: KytRegisterAddressInput,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self { address: value.address? })
            }
        }
        impl ::std::convert::From<super::KytRegisterAddressInput>
        for KytRegisterAddressInput {
            fn from(value: super::KytRegisterAddressInput) -> Self {
                Self { address: Ok(value.address) }
            }
        }
        #[derive(Clone, Debug)]
        pub struct KytRegisterAddressResponse {
            address: ::std::result::Result<::std::string::String, ::std::string::String>,
        }
        impl ::std::default::Default for KytRegisterAddressResponse {
            fn default() -> Self {
                Self {
                    address: Err("no value supplied for address".to_string()),
                }
            }
        }
        impl KytRegisterAddressResponse {
            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<KytRegisterAddressResponse>
        for super::KytRegisterAddressResponse {
            type Error = super::error::ConversionError;
            fn try_from(
                value: KytRegisterAddressResponse,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self { address: value.address? })
            }
        }
        impl ::std::convert::From<super::KytRegisterAddressResponse>
        for KytRegisterAddressResponse {
            fn from(value: super::KytRegisterAddressResponse) -> Self {
                Self { address: Ok(value.address) }
            }
        }
        #[derive(Clone, Debug)]
        pub struct KytRegisterTransferInput {
            asset: ::std::result::Result<::std::string::String, ::std::string::String>,
            direction: ::std::result::Result<
                super::TransferDirection,
                ::std::string::String,
            >,
            network: ::std::result::Result<super::KytNetwork, ::std::string::String>,
            transfer_reference: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for KytRegisterTransferInput {
            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 KytRegisterTransferInput {
            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::TransferDirection>,
                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::KytNetwork>,
                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<KytRegisterTransferInput>
        for super::KytRegisterTransferInput {
            type Error = super::error::ConversionError;
            fn try_from(
                value: KytRegisterTransferInput,
            ) -> ::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::KytRegisterTransferInput>
        for KytRegisterTransferInput {
            fn from(value: super::KytRegisterTransferInput) -> 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 KytRegisterWithdrawalInput {
            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::KytNetwork, ::std::string::String>,
        }
        impl ::std::default::Default for KytRegisterWithdrawalInput {
            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 KytRegisterWithdrawalInput {
            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::KytNetwork>,
                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<KytRegisterWithdrawalInput>
        for super::KytRegisterWithdrawalInput {
            type Error = super::error::ConversionError;
            fn try_from(
                value: KytRegisterWithdrawalInput,
            ) -> ::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::KytRegisterWithdrawalInput>
        for KytRegisterWithdrawalInput {
            fn from(value: super::KytRegisterWithdrawalInput) -> 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 KytTransferBaseResponse {
            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 KytTransferBaseResponse {
            fn default() -> Self {
                Self {
                    asset: Err("no value supplied for asset".to_string()),
                    asset_amount: Ok(Default::default()),
                    asset_id: Ok(Default::default()),
                    external_id: Err("no value supplied for external_id".to_string()),
                    idx: Ok(Default::default()),
                    memo: Ok(Default::default()),
                    network: Err("no value supplied for network".to_string()),
                    output_address: Ok(Default::default()),
                    timestamp: Ok(Default::default()),
                    transfer_reference: Err(
                        "no value supplied for transfer_reference".to_string(),
                    ),
                    tx: Ok(Default::default()),
                    updated_at: Ok(Default::default()),
                    usd_amount: Ok(Default::default()),
                }
            }
        }
        impl KytTransferBaseResponse {
            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<KytTransferBaseResponse>
        for super::KytTransferBaseResponse {
            type Error = super::error::ConversionError;
            fn try_from(
                value: KytTransferBaseResponse,
            ) -> ::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::KytTransferBaseResponse>
        for KytTransferBaseResponse {
            fn from(value: super::KytTransferBaseResponse) -> 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 KytWithdrawalAddressIdentificationsResponse {
            chainalysis_identifications: ::std::result::Result<
                ::std::vec::Vec<super::KytAddressIdentification>,
                ::std::string::String,
            >,
            custom_addresses: ::std::result::Result<
                ::std::vec::Vec<::serde_json::Value>,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for KytWithdrawalAddressIdentificationsResponse {
            fn default() -> Self {
                Self {
                    chainalysis_identifications: Ok(Default::default()),
                    custom_addresses: Ok(Default::default()),
                }
            }
        }
        impl KytWithdrawalAddressIdentificationsResponse {
            pub fn chainalysis_identifications<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<
                    ::std::vec::Vec<super::KytAddressIdentification>,
                >,
                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<::serde_json::Value>>,
                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<KytWithdrawalAddressIdentificationsResponse>
        for super::KytWithdrawalAddressIdentificationsResponse {
            type Error = super::error::ConversionError;
            fn try_from(
                value: KytWithdrawalAddressIdentificationsResponse,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    chainalysis_identifications: value.chainalysis_identifications?,
                    custom_addresses: value.custom_addresses?,
                })
            }
        }
        impl ::std::convert::From<super::KytWithdrawalAddressIdentificationsResponse>
        for KytWithdrawalAddressIdentificationsResponse {
            fn from(value: super::KytWithdrawalAddressIdentificationsResponse) -> Self {
                Self {
                    chainalysis_identifications: Ok(value.chainalysis_identifications),
                    custom_addresses: Ok(value.custom_addresses),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct KytWithdrawalBaseResponse {
            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 KytWithdrawalBaseResponse {
            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: Ok(Default::default()),
                    attempt_identifier: Err(
                        "no value supplied for attempt_identifier".to_string(),
                    ),
                    external_id: Err("no value supplied for external_id".to_string()),
                    memo: Ok(Default::default()),
                    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 KytWithdrawalBaseResponse {
            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<KytWithdrawalBaseResponse>
        for super::KytWithdrawalBaseResponse {
            type Error = super::error::ConversionError;
            fn try_from(
                value: KytWithdrawalBaseResponse,
            ) -> ::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::KytWithdrawalBaseResponse>
        for KytWithdrawalBaseResponse {
            fn from(value: super::KytWithdrawalBaseResponse) -> 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 NetWorthByTokensItem {
            accu_amount: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            amount: ::std::result::Result<::std::string::String, ::std::string::String>,
            avg_cost_usd: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            chain: ::std::result::Result<::std::string::String, ::std::string::String>,
            decimals: ::std::result::Result<i32, ::std::string::String>,
            is_active: ::std::result::Result<bool, ::std::string::String>,
            last_active_at: ::std::result::Result<
                ::std::option::Option<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,
            >,
            realized_pnl_in_usd: ::std::result::Result<
                ::std::option::Option<::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,
            >,
            unrealized_pnl_in_usd: ::std::result::Result<
                ::std::option::Option<::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,
            >,
            wallet_token_tags: ::std::result::Result<
                ::std::vec::Vec<::std::string::String>,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for NetWorthByTokensItem {
            fn default() -> Self {
                Self {
                    accu_amount: Ok(Default::default()),
                    amount: Err("no value supplied for amount".to_string()),
                    avg_cost_usd: Ok(Default::default()),
                    chain: Err("no value supplied for chain".to_string()),
                    decimals: Err("no value supplied for decimals".to_string()),
                    is_active: Err("no value supplied for is_active".to_string()),
                    last_active_at: Ok(Default::default()),
                    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()),
                    realized_pnl_in_usd: Ok(Default::default()),
                    symbol: Err("no value supplied for symbol".to_string()),
                    token_address: Err(
                        "no value supplied for token_address".to_string(),
                    ),
                    unrealized_pnl_in_usd: Ok(Default::default()),
                    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()),
                    wallet_token_tags: Ok(Default::default()),
                }
            }
        }
        impl NetWorthByTokensItem {
            pub fn accu_amount<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.accu_amount = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for accu_amount: {}", 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 avg_cost_usd<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.avg_cost_usd = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for avg_cost_usd: {}", 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<i32>,
                T::Error: ::std::fmt::Display,
            {
                self.decimals = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for decimals: {}", e)
                    });
                self
            }
            pub fn is_active<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<bool>,
                T::Error: ::std::fmt::Display,
            {
                self.is_active = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for is_active: {}", e)
                    });
                self
            }
            pub fn last_active_at<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<i64>>,
                T::Error: ::std::fmt::Display,
            {
                self.last_active_at = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for last_active_at: {}", 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 realized_pnl_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.realized_pnl_in_usd = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for realized_pnl_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 unrealized_pnl_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.unrealized_pnl_in_usd = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for unrealized_pnl_in_usd: {}",
                            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
            }
            pub fn wallet_token_tags<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::vec::Vec<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.wallet_token_tags = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for wallet_token_tags: {}",
                            e
                        )
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<NetWorthByTokensItem>
        for super::NetWorthByTokensItem {
            type Error = super::error::ConversionError;
            fn try_from(
                value: NetWorthByTokensItem,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    accu_amount: value.accu_amount?,
                    amount: value.amount?,
                    avg_cost_usd: value.avg_cost_usd?,
                    chain: value.chain?,
                    decimals: value.decimals?,
                    is_active: value.is_active?,
                    last_active_at: value.last_active_at?,
                    logo_uri: value.logo_uri?,
                    name: value.name?,
                    price_in_native: value.price_in_native?,
                    price_in_usd: value.price_in_usd?,
                    realized_pnl_in_usd: value.realized_pnl_in_usd?,
                    symbol: value.symbol?,
                    token_address: value.token_address?,
                    unrealized_pnl_in_usd: value.unrealized_pnl_in_usd?,
                    value_in_native: value.value_in_native?,
                    value_in_usd: value.value_in_usd?,
                    wallet_token_tags: value.wallet_token_tags?,
                })
            }
        }
        impl ::std::convert::From<super::NetWorthByTokensItem> for NetWorthByTokensItem {
            fn from(value: super::NetWorthByTokensItem) -> Self {
                Self {
                    accu_amount: Ok(value.accu_amount),
                    amount: Ok(value.amount),
                    avg_cost_usd: Ok(value.avg_cost_usd),
                    chain: Ok(value.chain),
                    decimals: Ok(value.decimals),
                    is_active: Ok(value.is_active),
                    last_active_at: Ok(value.last_active_at),
                    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),
                    realized_pnl_in_usd: Ok(value.realized_pnl_in_usd),
                    symbol: Ok(value.symbol),
                    token_address: Ok(value.token_address),
                    unrealized_pnl_in_usd: Ok(value.unrealized_pnl_in_usd),
                    value_in_native: Ok(value.value_in_native),
                    value_in_usd: Ok(value.value_in_usd),
                    wallet_token_tags: Ok(value.wallet_token_tags),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct NetWorthByTokensResult {
            current_timestamp: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            data: ::std::result::Result<
                ::std::vec::Vec<super::NetWorthByTokensItem>,
                ::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 NetWorthByTokensResult {
            fn default() -> Self {
                Self {
                    current_timestamp: Err(
                        "no value supplied for current_timestamp".to_string(),
                    ),
                    data: Err("no value supplied for data".to_string()),
                    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 NetWorthByTokensResult {
            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::NetWorthByTokensItem>>,
                T::Error: ::std::fmt::Display,
            {
                self.data = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for data: {}", 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<NetWorthByTokensResult>
        for super::NetWorthByTokensResult {
            type Error = super::error::ConversionError;
            fn try_from(
                value: NetWorthByTokensResult,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    current_timestamp: value.current_timestamp?,
                    data: value.data?,
                    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::NetWorthByTokensResult>
        for NetWorthByTokensResult {
            fn from(value: super::NetWorthByTokensResult) -> Self {
                Self {
                    current_timestamp: Ok(value.current_timestamp),
                    data: Ok(value.data),
                    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 NetWorthHistoryItem {
            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 NetWorthHistoryItem {
            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 NetWorthHistoryItem {
            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<NetWorthHistoryItem>
        for super::NetWorthHistoryItem {
            type Error = super::error::ConversionError;
            fn try_from(
                value: NetWorthHistoryItem,
            ) -> ::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::NetWorthHistoryItem> for NetWorthHistoryItem {
            fn from(value: super::NetWorthHistoryItem) -> 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 NetWorthSummaryValue {
            value: ::std::result::Result<::std::string::String, ::std::string::String>,
        }
        impl ::std::default::Default for NetWorthSummaryValue {
            fn default() -> Self {
                Self {
                    value: Err("no value supplied for value".to_string()),
                }
            }
        }
        impl NetWorthSummaryValue {
            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<NetWorthSummaryValue>
        for super::NetWorthSummaryValue {
            type Error = super::error::ConversionError;
            fn try_from(
                value: NetWorthSummaryValue,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self { value: value.value? })
            }
        }
        impl ::std::convert::From<super::NetWorthSummaryValue> for NetWorthSummaryValue {
            fn from(value: super::NetWorthSummaryValue) -> Self {
                Self { value: Ok(value.value) }
            }
        }
        #[derive(Clone, Debug)]
        pub struct PageResponseBalanceUpdate {
            data: ::std::result::Result<
                ::std::vec::Vec<super::PageResponseBalanceUpdateDataItem>,
                ::std::string::String,
            >,
            end_cursor: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            has_next: ::std::result::Result<
                ::std::option::Option<bool>,
                ::std::string::String,
            >,
            has_prev: ::std::result::Result<
                ::std::option::Option<bool>,
                ::std::string::String,
            >,
            start_cursor: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for PageResponseBalanceUpdate {
            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()),
                }
            }
        }
        impl PageResponseBalanceUpdate {
            pub fn data<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<
                    ::std::vec::Vec<super::PageResponseBalanceUpdateDataItem>,
                >,
                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<::std::option::Option<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<::std::option::Option<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<PageResponseBalanceUpdate>
        for super::PageResponseBalanceUpdate {
            type Error = super::error::ConversionError;
            fn try_from(
                value: PageResponseBalanceUpdate,
            ) -> ::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::PageResponseBalanceUpdate>
        for PageResponseBalanceUpdate {
            fn from(value: super::PageResponseBalanceUpdate) -> 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 PageResponseBalanceUpdateDataItem {
            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<
                ::std::option::Option<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 PageResponseBalanceUpdateDataItem {
            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: Ok(Default::default()),
                    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 PageResponseBalanceUpdateDataItem {
            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<::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 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<PageResponseBalanceUpdateDataItem>
        for super::PageResponseBalanceUpdateDataItem {
            type Error = super::error::ConversionError;
            fn try_from(
                value: PageResponseBalanceUpdateDataItem,
            ) -> ::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::PageResponseBalanceUpdateDataItem>
        for PageResponseBalanceUpdateDataItem {
            fn from(value: super::PageResponseBalanceUpdateDataItem) -> 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 PageResponseDevToken {
            data: ::std::result::Result<
                ::std::vec::Vec<super::PageResponseDevTokenDataItem>,
                ::std::string::String,
            >,
            end_cursor: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            has_next: ::std::result::Result<
                ::std::option::Option<bool>,
                ::std::string::String,
            >,
            has_prev: ::std::result::Result<
                ::std::option::Option<bool>,
                ::std::string::String,
            >,
            start_cursor: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for PageResponseDevToken {
            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()),
                }
            }
        }
        impl PageResponseDevToken {
            pub fn data<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<
                    ::std::vec::Vec<super::PageResponseDevTokenDataItem>,
                >,
                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<::std::option::Option<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<::std::option::Option<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<PageResponseDevToken>
        for super::PageResponseDevToken {
            type Error = super::error::ConversionError;
            fn try_from(
                value: PageResponseDevToken,
            ) -> ::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::PageResponseDevToken> for PageResponseDevToken {
            fn from(value: super::PageResponseDevToken) -> 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 PageResponseDevTokenDataItem {
            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::TokenStats, ::std::string::String>,
        }
        impl ::std::default::Default for PageResponseDevTokenDataItem {
            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 PageResponseDevTokenDataItem {
            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::TokenStats>,
                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<PageResponseDevTokenDataItem>
        for super::PageResponseDevTokenDataItem {
            type Error = super::error::ConversionError;
            fn try_from(
                value: PageResponseDevTokenDataItem,
            ) -> ::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::PageResponseDevTokenDataItem>
        for PageResponseDevTokenDataItem {
            fn from(value: super::PageResponseDevTokenDataItem) -> 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 PageResponseDex {
            data: ::std::result::Result<
                ::std::vec::Vec<super::PageResponseDexDataItem>,
                ::std::string::String,
            >,
            end_cursor: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            has_next: ::std::result::Result<
                ::std::option::Option<bool>,
                ::std::string::String,
            >,
            has_prev: ::std::result::Result<
                ::std::option::Option<bool>,
                ::std::string::String,
            >,
            start_cursor: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for PageResponseDex {
            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()),
                }
            }
        }
        impl PageResponseDex {
            pub fn data<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<
                    ::std::vec::Vec<super::PageResponseDexDataItem>,
                >,
                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<::std::option::Option<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<::std::option::Option<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<PageResponseDex> for super::PageResponseDex {
            type Error = super::error::ConversionError;
            fn try_from(
                value: PageResponseDex,
            ) -> ::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::PageResponseDex> for PageResponseDex {
            fn from(value: super::PageResponseDex) -> 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 PageResponseDexDataItem {
            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<super::DexProtocolFamily>,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for PageResponseDexDataItem {
            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 PageResponseDexDataItem {
            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<super::DexProtocolFamily>,
                >,
                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<PageResponseDexDataItem>
        for super::PageResponseDexDataItem {
            type Error = super::error::ConversionError;
            fn try_from(
                value: PageResponseDexDataItem,
            ) -> ::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::PageResponseDexDataItem>
        for PageResponseDexDataItem {
            fn from(value: super::PageResponseDexDataItem) -> 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 PageResponseDexPool {
            data: ::std::result::Result<
                ::std::vec::Vec<super::PageResponseDexPoolDataItem>,
                ::std::string::String,
            >,
            end_cursor: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            has_next: ::std::result::Result<
                ::std::option::Option<bool>,
                ::std::string::String,
            >,
            has_prev: ::std::result::Result<
                ::std::option::Option<bool>,
                ::std::string::String,
            >,
            start_cursor: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for PageResponseDexPool {
            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()),
                }
            }
        }
        impl PageResponseDexPool {
            pub fn data<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<
                    ::std::vec::Vec<super::PageResponseDexPoolDataItem>,
                >,
                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<::std::option::Option<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<::std::option::Option<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<PageResponseDexPool>
        for super::PageResponseDexPool {
            type Error = super::error::ConversionError;
            fn try_from(
                value: PageResponseDexPool,
            ) -> ::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::PageResponseDexPool> for PageResponseDexPool {
            fn from(value: super::PageResponseDexPool) -> 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 PageResponseDexPoolDataItem {
            chain: ::std::result::Result<::std::string::String, ::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,
            >,
            token_a_address: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            token_b_address: ::std::result::Result<
                ::std::string::String,
                ::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,
            >,
        }
        impl ::std::default::Default for PageResponseDexPoolDataItem {
            fn default() -> Self {
                Self {
                    chain: Err("no value supplied for chain".to_string()),
                    pool_address: Err("no value supplied for pool_address".to_string()),
                    program_address: Ok(Default::default()),
                    protocol_family: Ok(Default::default()),
                    token_a_address: Err(
                        "no value supplied for token_a_address".to_string(),
                    ),
                    token_b_address: Err(
                        "no value supplied for token_b_address".to_string(),
                    ),
                    tvl_in_sol: Ok(Default::default()),
                    tvl_in_usd: Ok(Default::default()),
                }
            }
        }
        impl PageResponseDexPoolDataItem {
            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 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 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_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 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
            }
        }
        impl ::std::convert::TryFrom<PageResponseDexPoolDataItem>
        for super::PageResponseDexPoolDataItem {
            type Error = super::error::ConversionError;
            fn try_from(
                value: PageResponseDexPoolDataItem,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    chain: value.chain?,
                    pool_address: value.pool_address?,
                    program_address: value.program_address?,
                    protocol_family: value.protocol_family?,
                    token_a_address: value.token_a_address?,
                    token_b_address: value.token_b_address?,
                    tvl_in_sol: value.tvl_in_sol?,
                    tvl_in_usd: value.tvl_in_usd?,
                })
            }
        }
        impl ::std::convert::From<super::PageResponseDexPoolDataItem>
        for PageResponseDexPoolDataItem {
            fn from(value: super::PageResponseDexPoolDataItem) -> Self {
                Self {
                    chain: Ok(value.chain),
                    pool_address: Ok(value.pool_address),
                    program_address: Ok(value.program_address),
                    protocol_family: Ok(value.protocol_family),
                    token_a_address: Ok(value.token_a_address),
                    token_b_address: Ok(value.token_b_address),
                    tvl_in_sol: Ok(value.tvl_in_sol),
                    tvl_in_usd: Ok(value.tvl_in_usd),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct PageResponseDexPoolSnapshot {
            data: ::std::result::Result<
                ::std::vec::Vec<super::PageResponseDexPoolSnapshotDataItem>,
                ::std::string::String,
            >,
            end_cursor: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            has_next: ::std::result::Result<
                ::std::option::Option<bool>,
                ::std::string::String,
            >,
            has_prev: ::std::result::Result<
                ::std::option::Option<bool>,
                ::std::string::String,
            >,
            start_cursor: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for PageResponseDexPoolSnapshot {
            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()),
                }
            }
        }
        impl PageResponseDexPoolSnapshot {
            pub fn data<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<
                    ::std::vec::Vec<super::PageResponseDexPoolSnapshotDataItem>,
                >,
                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<::std::option::Option<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<::std::option::Option<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<PageResponseDexPoolSnapshot>
        for super::PageResponseDexPoolSnapshot {
            type Error = super::error::ConversionError;
            fn try_from(
                value: PageResponseDexPoolSnapshot,
            ) -> ::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::PageResponseDexPoolSnapshot>
        for PageResponseDexPoolSnapshot {
            fn from(value: super::PageResponseDexPoolSnapshot) -> 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 PageResponseDexPoolSnapshotDataItem {
            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::DexPoolTokenSnapshot,
                ::std::string::String,
            >,
            token_b: ::std::result::Result<
                super::DexPoolTokenSnapshot,
                ::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 PageResponseDexPoolSnapshotDataItem {
            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 PageResponseDexPoolSnapshotDataItem {
            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::DexPoolTokenSnapshot>,
                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::DexPoolTokenSnapshot>,
                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<PageResponseDexPoolSnapshotDataItem>
        for super::PageResponseDexPoolSnapshotDataItem {
            type Error = super::error::ConversionError;
            fn try_from(
                value: PageResponseDexPoolSnapshotDataItem,
            ) -> ::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::PageResponseDexPoolSnapshotDataItem>
        for PageResponseDexPoolSnapshotDataItem {
            fn from(value: super::PageResponseDexPoolSnapshotDataItem) -> 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 PageResponseNetWorthByTokensItem {
            data: ::std::result::Result<
                ::std::vec::Vec<super::PageResponseNetWorthByTokensItemDataItem>,
                ::std::string::String,
            >,
            end_cursor: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            has_next: ::std::result::Result<
                ::std::option::Option<bool>,
                ::std::string::String,
            >,
            has_prev: ::std::result::Result<
                ::std::option::Option<bool>,
                ::std::string::String,
            >,
            start_cursor: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for PageResponseNetWorthByTokensItem {
            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()),
                }
            }
        }
        impl PageResponseNetWorthByTokensItem {
            pub fn data<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<
                    ::std::vec::Vec<super::PageResponseNetWorthByTokensItemDataItem>,
                >,
                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<::std::option::Option<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<::std::option::Option<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<PageResponseNetWorthByTokensItem>
        for super::PageResponseNetWorthByTokensItem {
            type Error = super::error::ConversionError;
            fn try_from(
                value: PageResponseNetWorthByTokensItem,
            ) -> ::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::PageResponseNetWorthByTokensItem>
        for PageResponseNetWorthByTokensItem {
            fn from(value: super::PageResponseNetWorthByTokensItem) -> 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 PageResponseNetWorthByTokensItemDataItem {
            accu_amount: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            amount: ::std::result::Result<::std::string::String, ::std::string::String>,
            avg_cost_usd: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            chain: ::std::result::Result<::std::string::String, ::std::string::String>,
            decimals: ::std::result::Result<i32, ::std::string::String>,
            is_active: ::std::result::Result<bool, ::std::string::String>,
            last_active_at: ::std::result::Result<
                ::std::option::Option<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,
            >,
            realized_pnl_in_usd: ::std::result::Result<
                ::std::option::Option<::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,
            >,
            unrealized_pnl_in_usd: ::std::result::Result<
                ::std::option::Option<::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,
            >,
            wallet_token_tags: ::std::result::Result<
                ::std::vec::Vec<::std::string::String>,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for PageResponseNetWorthByTokensItemDataItem {
            fn default() -> Self {
                Self {
                    accu_amount: Ok(Default::default()),
                    amount: Err("no value supplied for amount".to_string()),
                    avg_cost_usd: Ok(Default::default()),
                    chain: Err("no value supplied for chain".to_string()),
                    decimals: Err("no value supplied for decimals".to_string()),
                    is_active: Err("no value supplied for is_active".to_string()),
                    last_active_at: Ok(Default::default()),
                    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()),
                    realized_pnl_in_usd: Ok(Default::default()),
                    symbol: Err("no value supplied for symbol".to_string()),
                    token_address: Err(
                        "no value supplied for token_address".to_string(),
                    ),
                    unrealized_pnl_in_usd: Ok(Default::default()),
                    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()),
                    wallet_token_tags: Ok(Default::default()),
                }
            }
        }
        impl PageResponseNetWorthByTokensItemDataItem {
            pub fn accu_amount<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.accu_amount = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for accu_amount: {}", 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 avg_cost_usd<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.avg_cost_usd = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for avg_cost_usd: {}", 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<i32>,
                T::Error: ::std::fmt::Display,
            {
                self.decimals = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for decimals: {}", e)
                    });
                self
            }
            pub fn is_active<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<bool>,
                T::Error: ::std::fmt::Display,
            {
                self.is_active = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for is_active: {}", e)
                    });
                self
            }
            pub fn last_active_at<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<i64>>,
                T::Error: ::std::fmt::Display,
            {
                self.last_active_at = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for last_active_at: {}", 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 realized_pnl_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.realized_pnl_in_usd = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for realized_pnl_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 unrealized_pnl_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.unrealized_pnl_in_usd = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for unrealized_pnl_in_usd: {}",
                            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
            }
            pub fn wallet_token_tags<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::vec::Vec<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.wallet_token_tags = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for wallet_token_tags: {}",
                            e
                        )
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<PageResponseNetWorthByTokensItemDataItem>
        for super::PageResponseNetWorthByTokensItemDataItem {
            type Error = super::error::ConversionError;
            fn try_from(
                value: PageResponseNetWorthByTokensItemDataItem,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    accu_amount: value.accu_amount?,
                    amount: value.amount?,
                    avg_cost_usd: value.avg_cost_usd?,
                    chain: value.chain?,
                    decimals: value.decimals?,
                    is_active: value.is_active?,
                    last_active_at: value.last_active_at?,
                    logo_uri: value.logo_uri?,
                    name: value.name?,
                    price_in_native: value.price_in_native?,
                    price_in_usd: value.price_in_usd?,
                    realized_pnl_in_usd: value.realized_pnl_in_usd?,
                    symbol: value.symbol?,
                    token_address: value.token_address?,
                    unrealized_pnl_in_usd: value.unrealized_pnl_in_usd?,
                    value_in_native: value.value_in_native?,
                    value_in_usd: value.value_in_usd?,
                    wallet_token_tags: value.wallet_token_tags?,
                })
            }
        }
        impl ::std::convert::From<super::PageResponseNetWorthByTokensItemDataItem>
        for PageResponseNetWorthByTokensItemDataItem {
            fn from(value: super::PageResponseNetWorthByTokensItemDataItem) -> Self {
                Self {
                    accu_amount: Ok(value.accu_amount),
                    amount: Ok(value.amount),
                    avg_cost_usd: Ok(value.avg_cost_usd),
                    chain: Ok(value.chain),
                    decimals: Ok(value.decimals),
                    is_active: Ok(value.is_active),
                    last_active_at: Ok(value.last_active_at),
                    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),
                    realized_pnl_in_usd: Ok(value.realized_pnl_in_usd),
                    symbol: Ok(value.symbol),
                    token_address: Ok(value.token_address),
                    unrealized_pnl_in_usd: Ok(value.unrealized_pnl_in_usd),
                    value_in_native: Ok(value.value_in_native),
                    value_in_usd: Ok(value.value_in_usd),
                    wallet_token_tags: Ok(value.wallet_token_tags),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct PageResponseToken {
            data: ::std::result::Result<
                ::std::vec::Vec<super::PageResponseTokenDataItem>,
                ::std::string::String,
            >,
            end_cursor: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            has_next: ::std::result::Result<
                ::std::option::Option<bool>,
                ::std::string::String,
            >,
            has_prev: ::std::result::Result<
                ::std::option::Option<bool>,
                ::std::string::String,
            >,
            start_cursor: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for PageResponseToken {
            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()),
                }
            }
        }
        impl PageResponseToken {
            pub fn data<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<
                    ::std::vec::Vec<super::PageResponseTokenDataItem>,
                >,
                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<::std::option::Option<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<::std::option::Option<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<PageResponseToken> for super::PageResponseToken {
            type Error = super::error::ConversionError;
            fn try_from(
                value: PageResponseToken,
            ) -> ::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::PageResponseToken> for PageResponseToken {
            fn from(value: super::PageResponseToken) -> 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 PageResponseTokenDataItem {
            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<i32, ::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<
                ::std::option::Option<super::TokenExtra>,
                ::std::string::String,
            >,
            extra: ::std::result::Result<
                ::std::option::Option<super::TokenExtra>,
                ::std::string::String,
            >,
            image_dup: ::std::result::Result<
                ::std::option::Option<bool>,
                ::std::string::String,
            >,
            image_hash: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            image_url: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            market: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            market_data: ::std::result::Result<
                ::std::option::Option<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>,
            normalized_name: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            social_medias: ::std::result::Result<
                ::std::option::Option<super::TokenSocialMedias>,
                ::std::string::String,
            >,
            stats: ::std::result::Result<
                ::std::option::Option<super::TokenStats>,
                ::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::TokenCreator>,
                ::std::string::String,
            >,
            uri: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for PageResponseTokenDataItem {
            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_dup: Ok(Default::default()),
                    image_hash: Ok(Default::default()),
                    image_url: Ok(Default::default()),
                    market: Ok(Default::default()),
                    market_data: Ok(Default::default()),
                    metadata_address: Ok(Default::default()),
                    name: Err("no value supplied for name".to_string()),
                    normalized_name: Ok(Default::default()),
                    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 PageResponseTokenDataItem {
            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<i32>,
                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<::std::option::Option<super::TokenExtra>>,
                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::TokenExtra>>,
                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_dup<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<bool>>,
                T::Error: ::std::fmt::Display,
            {
                self.image_dup = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for image_dup: {}", e)
                    });
                self
            }
            pub fn image_hash<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.image_hash = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for image_hash: {}", 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 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<
                    ::std::option::Option<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 normalized_name<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.normalized_name = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for normalized_name: {}", e
                        )
                    });
                self
            }
            pub fn social_medias<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<
                    ::std::option::Option<super::TokenSocialMedias>,
                >,
                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::TokenStats>>,
                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::TokenCreator>>,
                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<PageResponseTokenDataItem>
        for super::PageResponseTokenDataItem {
            type Error = super::error::ConversionError;
            fn try_from(
                value: PageResponseTokenDataItem,
            ) -> ::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_dup: value.image_dup?,
                    image_hash: value.image_hash?,
                    image_url: value.image_url?,
                    market: value.market?,
                    market_data: value.market_data?,
                    metadata_address: value.metadata_address?,
                    name: value.name?,
                    normalized_name: value.normalized_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::PageResponseTokenDataItem>
        for PageResponseTokenDataItem {
            fn from(value: super::PageResponseTokenDataItem) -> 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_dup: Ok(value.image_dup),
                    image_hash: Ok(value.image_hash),
                    image_url: Ok(value.image_url),
                    market: Ok(value.market),
                    market_data: Ok(value.market_data),
                    metadata_address: Ok(value.metadata_address),
                    name: Ok(value.name),
                    normalized_name: Ok(value.normalized_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 PageResponseTokenHolder {
            data: ::std::result::Result<
                ::std::vec::Vec<super::PageResponseTokenHolderDataItem>,
                ::std::string::String,
            >,
            end_cursor: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            has_next: ::std::result::Result<
                ::std::option::Option<bool>,
                ::std::string::String,
            >,
            has_prev: ::std::result::Result<
                ::std::option::Option<bool>,
                ::std::string::String,
            >,
            start_cursor: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for PageResponseTokenHolder {
            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()),
                }
            }
        }
        impl PageResponseTokenHolder {
            pub fn data<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<
                    ::std::vec::Vec<super::PageResponseTokenHolderDataItem>,
                >,
                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<::std::option::Option<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<::std::option::Option<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<PageResponseTokenHolder>
        for super::PageResponseTokenHolder {
            type Error = super::error::ConversionError;
            fn try_from(
                value: PageResponseTokenHolder,
            ) -> ::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::PageResponseTokenHolder>
        for PageResponseTokenHolder {
            fn from(value: super::PageResponseTokenHolder) -> 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 PageResponseTokenHolderDataItem {
            accu_cost: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            amount: ::std::result::Result<::std::string::String, ::std::string::String>,
            amount_in_usd: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            avg_buy_price_usd: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            avg_cost_usd: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            avg_sell_price_usd: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            buy_amount_cur: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            buy_volume_native: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            buy_volume_usd: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            end_holding_at: ::std::result::Result<
                ::std::option::Option<i64>,
                ::std::string::String,
            >,
            first_buy_time: ::std::result::Result<
                ::std::option::Option<i64>,
                ::std::string::String,
            >,
            history_bought_cost: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            history_bought_fee: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            history_sold_fee: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            history_sold_income: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            history_transfer_in_amount: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            history_transfer_in_cost: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            history_transfer_out_amount: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            history_transfer_out_income: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            is_closed: ::std::result::Result<
                ::std::option::Option<bool>,
                ::std::string::String,
            >,
            is_transfer_in: ::std::result::Result<
                ::std::option::Option<bool>,
                ::std::string::String,
            >,
            last_active_at: ::std::result::Result<
                ::std::option::Option<i64>,
                ::std::string::String,
            >,
            loss_count: ::std::result::Result<
                ::std::option::Option<i64>,
                ::std::string::String,
            >,
            maker_token_tags: ::std::result::Result<
                ::std::vec::Vec<::std::string::String>,
                ::std::string::String,
            >,
            native_balance: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            netflow_usd: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            percentage: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            position_cost_usd: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            realized_pnl_ratio: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            realized_profit: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            roi: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            sell_amount_cur: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            sell_amount_percentage: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            sell_volume_native: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            sell_volume_usd: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            start_holding_at: ::std::result::Result<
                ::std::option::Option<i64>,
                ::std::string::String,
            >,
            tags: ::std::result::Result<
                ::std::vec::Vec<::std::string::String>,
                ::std::string::String,
            >,
            total_buy_count: ::std::result::Result<
                ::std::option::Option<i64>,
                ::std::string::String,
            >,
            total_cost_usd: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            total_profit: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            total_sell_count: ::std::result::Result<
                ::std::option::Option<i64>,
                ::std::string::String,
            >,
            transfer_in_amount7d: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            transfer_in_count: ::std::result::Result<
                ::std::option::Option<i64>,
                ::std::string::String,
            >,
            transfer_out_amount7d: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            transfer_out_count: ::std::result::Result<
                ::std::option::Option<i64>,
                ::std::string::String,
            >,
            unrealized_profit: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            wallet_address: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            wallet_tag_v2: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            win_count: ::std::result::Result<
                ::std::option::Option<i64>,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for PageResponseTokenHolderDataItem {
            fn default() -> Self {
                Self {
                    accu_cost: Ok(Default::default()),
                    amount: Err("no value supplied for amount".to_string()),
                    amount_in_usd: Err(
                        "no value supplied for amount_in_usd".to_string(),
                    ),
                    avg_buy_price_usd: Ok(Default::default()),
                    avg_cost_usd: Ok(Default::default()),
                    avg_sell_price_usd: Ok(Default::default()),
                    buy_amount_cur: Ok(Default::default()),
                    buy_volume_native: Ok(Default::default()),
                    buy_volume_usd: Ok(Default::default()),
                    end_holding_at: Ok(Default::default()),
                    first_buy_time: Ok(Default::default()),
                    history_bought_cost: Ok(Default::default()),
                    history_bought_fee: Ok(Default::default()),
                    history_sold_fee: Ok(Default::default()),
                    history_sold_income: Ok(Default::default()),
                    history_transfer_in_amount: Ok(Default::default()),
                    history_transfer_in_cost: Ok(Default::default()),
                    history_transfer_out_amount: Ok(Default::default()),
                    history_transfer_out_income: Ok(Default::default()),
                    is_closed: Ok(Default::default()),
                    is_transfer_in: Ok(Default::default()),
                    last_active_at: Ok(Default::default()),
                    loss_count: Ok(Default::default()),
                    maker_token_tags: Ok(Default::default()),
                    native_balance: Ok(Default::default()),
                    netflow_usd: Ok(Default::default()),
                    percentage: Err("no value supplied for percentage".to_string()),
                    position_cost_usd: Ok(Default::default()),
                    realized_pnl_ratio: Ok(Default::default()),
                    realized_profit: Ok(Default::default()),
                    roi: Ok(Default::default()),
                    sell_amount_cur: Ok(Default::default()),
                    sell_amount_percentage: Ok(Default::default()),
                    sell_volume_native: Ok(Default::default()),
                    sell_volume_usd: Ok(Default::default()),
                    start_holding_at: Ok(Default::default()),
                    tags: Ok(Default::default()),
                    total_buy_count: Ok(Default::default()),
                    total_cost_usd: Ok(Default::default()),
                    total_profit: Ok(Default::default()),
                    total_sell_count: Ok(Default::default()),
                    transfer_in_amount7d: Ok(Default::default()),
                    transfer_in_count: Ok(Default::default()),
                    transfer_out_amount7d: Ok(Default::default()),
                    transfer_out_count: Ok(Default::default()),
                    unrealized_profit: Ok(Default::default()),
                    wallet_address: Err(
                        "no value supplied for wallet_address".to_string(),
                    ),
                    wallet_tag_v2: Ok(Default::default()),
                    win_count: Ok(Default::default()),
                }
            }
        }
        impl PageResponseTokenHolderDataItem {
            pub fn accu_cost<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.accu_cost = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for accu_cost: {}", 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 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 avg_buy_price_usd<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.avg_buy_price_usd = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for avg_buy_price_usd: {}",
                            e
                        )
                    });
                self
            }
            pub fn avg_cost_usd<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.avg_cost_usd = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for avg_cost_usd: {}", e
                        )
                    });
                self
            }
            pub fn avg_sell_price_usd<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.avg_sell_price_usd = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for avg_sell_price_usd: {}",
                            e
                        )
                    });
                self
            }
            pub fn buy_amount_cur<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.buy_amount_cur = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for buy_amount_cur: {}", e
                        )
                    });
                self
            }
            pub fn buy_volume_native<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.buy_volume_native = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for buy_volume_native: {}",
                            e
                        )
                    });
                self
            }
            pub fn buy_volume_usd<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.buy_volume_usd = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for buy_volume_usd: {}", e
                        )
                    });
                self
            }
            pub fn end_holding_at<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<i64>>,
                T::Error: ::std::fmt::Display,
            {
                self.end_holding_at = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for end_holding_at: {}", e
                        )
                    });
                self
            }
            pub fn first_buy_time<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<i64>>,
                T::Error: ::std::fmt::Display,
            {
                self.first_buy_time = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for first_buy_time: {}", e
                        )
                    });
                self
            }
            pub fn history_bought_cost<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.history_bought_cost = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for history_bought_cost: {}",
                            e
                        )
                    });
                self
            }
            pub fn history_bought_fee<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.history_bought_fee = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for history_bought_fee: {}",
                            e
                        )
                    });
                self
            }
            pub fn history_sold_fee<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.history_sold_fee = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for history_sold_fee: {}", e
                        )
                    });
                self
            }
            pub fn history_sold_income<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.history_sold_income = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for history_sold_income: {}",
                            e
                        )
                    });
                self
            }
            pub fn history_transfer_in_amount<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.history_transfer_in_amount = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for history_transfer_in_amount: {}",
                            e
                        )
                    });
                self
            }
            pub fn history_transfer_in_cost<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.history_transfer_in_cost = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for history_transfer_in_cost: {}",
                            e
                        )
                    });
                self
            }
            pub fn history_transfer_out_amount<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.history_transfer_out_amount = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for history_transfer_out_amount: {}",
                            e
                        )
                    });
                self
            }
            pub fn history_transfer_out_income<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.history_transfer_out_income = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for history_transfer_out_income: {}",
                            e
                        )
                    });
                self
            }
            pub fn is_closed<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<bool>>,
                T::Error: ::std::fmt::Display,
            {
                self.is_closed = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for is_closed: {}", e)
                    });
                self
            }
            pub fn is_transfer_in<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<bool>>,
                T::Error: ::std::fmt::Display,
            {
                self.is_transfer_in = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for is_transfer_in: {}", e
                        )
                    });
                self
            }
            pub fn last_active_at<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<i64>>,
                T::Error: ::std::fmt::Display,
            {
                self.last_active_at = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for last_active_at: {}", e
                        )
                    });
                self
            }
            pub fn loss_count<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<i64>>,
                T::Error: ::std::fmt::Display,
            {
                self.loss_count = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for loss_count: {}", e)
                    });
                self
            }
            pub fn maker_token_tags<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::vec::Vec<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.maker_token_tags = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for maker_token_tags: {}", e
                        )
                    });
                self
            }
            pub fn native_balance<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.native_balance = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for native_balance: {}", e
                        )
                    });
                self
            }
            pub fn netflow_usd<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.netflow_usd = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for netflow_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 position_cost_usd<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.position_cost_usd = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for position_cost_usd: {}",
                            e
                        )
                    });
                self
            }
            pub fn realized_pnl_ratio<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.realized_pnl_ratio = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for realized_pnl_ratio: {}",
                            e
                        )
                    });
                self
            }
            pub fn realized_profit<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.realized_profit = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for realized_profit: {}", e
                        )
                    });
                self
            }
            pub fn roi<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.roi = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for roi: {}", e)
                    });
                self
            }
            pub fn sell_amount_cur<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.sell_amount_cur = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for sell_amount_cur: {}", e
                        )
                    });
                self
            }
            pub fn sell_amount_percentage<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.sell_amount_percentage = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for sell_amount_percentage: {}",
                            e
                        )
                    });
                self
            }
            pub fn sell_volume_native<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.sell_volume_native = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for sell_volume_native: {}",
                            e
                        )
                    });
                self
            }
            pub fn sell_volume_usd<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.sell_volume_usd = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for sell_volume_usd: {}", e
                        )
                    });
                self
            }
            pub fn start_holding_at<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<i64>>,
                T::Error: ::std::fmt::Display,
            {
                self.start_holding_at = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for start_holding_at: {}", e
                        )
                    });
                self
            }
            pub fn tags<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::vec::Vec<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.tags = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for tags: {}", e)
                    });
                self
            }
            pub fn total_buy_count<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<i64>>,
                T::Error: ::std::fmt::Display,
            {
                self.total_buy_count = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for total_buy_count: {}", e
                        )
                    });
                self
            }
            pub fn total_cost_usd<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.total_cost_usd = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for total_cost_usd: {}", e
                        )
                    });
                self
            }
            pub fn total_profit<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.total_profit = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for total_profit: {}", e
                        )
                    });
                self
            }
            pub fn total_sell_count<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<i64>>,
                T::Error: ::std::fmt::Display,
            {
                self.total_sell_count = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for total_sell_count: {}", e
                        )
                    });
                self
            }
            pub fn transfer_in_amount7d<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.transfer_in_amount7d = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for transfer_in_amount7d: {}",
                            e
                        )
                    });
                self
            }
            pub fn transfer_in_count<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<i64>>,
                T::Error: ::std::fmt::Display,
            {
                self.transfer_in_count = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for transfer_in_count: {}",
                            e
                        )
                    });
                self
            }
            pub fn transfer_out_amount7d<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.transfer_out_amount7d = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for transfer_out_amount7d: {}",
                            e
                        )
                    });
                self
            }
            pub fn transfer_out_count<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<i64>>,
                T::Error: ::std::fmt::Display,
            {
                self.transfer_out_count = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for transfer_out_count: {}",
                            e
                        )
                    });
                self
            }
            pub fn unrealized_profit<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.unrealized_profit = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for unrealized_profit: {}",
                            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 wallet_tag_v2<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.wallet_tag_v2 = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for wallet_tag_v2: {}", e
                        )
                    });
                self
            }
            pub fn win_count<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<i64>>,
                T::Error: ::std::fmt::Display,
            {
                self.win_count = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for win_count: {}", e)
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<PageResponseTokenHolderDataItem>
        for super::PageResponseTokenHolderDataItem {
            type Error = super::error::ConversionError;
            fn try_from(
                value: PageResponseTokenHolderDataItem,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    accu_cost: value.accu_cost?,
                    amount: value.amount?,
                    amount_in_usd: value.amount_in_usd?,
                    avg_buy_price_usd: value.avg_buy_price_usd?,
                    avg_cost_usd: value.avg_cost_usd?,
                    avg_sell_price_usd: value.avg_sell_price_usd?,
                    buy_amount_cur: value.buy_amount_cur?,
                    buy_volume_native: value.buy_volume_native?,
                    buy_volume_usd: value.buy_volume_usd?,
                    end_holding_at: value.end_holding_at?,
                    first_buy_time: value.first_buy_time?,
                    history_bought_cost: value.history_bought_cost?,
                    history_bought_fee: value.history_bought_fee?,
                    history_sold_fee: value.history_sold_fee?,
                    history_sold_income: value.history_sold_income?,
                    history_transfer_in_amount: value.history_transfer_in_amount?,
                    history_transfer_in_cost: value.history_transfer_in_cost?,
                    history_transfer_out_amount: value.history_transfer_out_amount?,
                    history_transfer_out_income: value.history_transfer_out_income?,
                    is_closed: value.is_closed?,
                    is_transfer_in: value.is_transfer_in?,
                    last_active_at: value.last_active_at?,
                    loss_count: value.loss_count?,
                    maker_token_tags: value.maker_token_tags?,
                    native_balance: value.native_balance?,
                    netflow_usd: value.netflow_usd?,
                    percentage: value.percentage?,
                    position_cost_usd: value.position_cost_usd?,
                    realized_pnl_ratio: value.realized_pnl_ratio?,
                    realized_profit: value.realized_profit?,
                    roi: value.roi?,
                    sell_amount_cur: value.sell_amount_cur?,
                    sell_amount_percentage: value.sell_amount_percentage?,
                    sell_volume_native: value.sell_volume_native?,
                    sell_volume_usd: value.sell_volume_usd?,
                    start_holding_at: value.start_holding_at?,
                    tags: value.tags?,
                    total_buy_count: value.total_buy_count?,
                    total_cost_usd: value.total_cost_usd?,
                    total_profit: value.total_profit?,
                    total_sell_count: value.total_sell_count?,
                    transfer_in_amount7d: value.transfer_in_amount7d?,
                    transfer_in_count: value.transfer_in_count?,
                    transfer_out_amount7d: value.transfer_out_amount7d?,
                    transfer_out_count: value.transfer_out_count?,
                    unrealized_profit: value.unrealized_profit?,
                    wallet_address: value.wallet_address?,
                    wallet_tag_v2: value.wallet_tag_v2?,
                    win_count: value.win_count?,
                })
            }
        }
        impl ::std::convert::From<super::PageResponseTokenHolderDataItem>
        for PageResponseTokenHolderDataItem {
            fn from(value: super::PageResponseTokenHolderDataItem) -> Self {
                Self {
                    accu_cost: Ok(value.accu_cost),
                    amount: Ok(value.amount),
                    amount_in_usd: Ok(value.amount_in_usd),
                    avg_buy_price_usd: Ok(value.avg_buy_price_usd),
                    avg_cost_usd: Ok(value.avg_cost_usd),
                    avg_sell_price_usd: Ok(value.avg_sell_price_usd),
                    buy_amount_cur: Ok(value.buy_amount_cur),
                    buy_volume_native: Ok(value.buy_volume_native),
                    buy_volume_usd: Ok(value.buy_volume_usd),
                    end_holding_at: Ok(value.end_holding_at),
                    first_buy_time: Ok(value.first_buy_time),
                    history_bought_cost: Ok(value.history_bought_cost),
                    history_bought_fee: Ok(value.history_bought_fee),
                    history_sold_fee: Ok(value.history_sold_fee),
                    history_sold_income: Ok(value.history_sold_income),
                    history_transfer_in_amount: Ok(value.history_transfer_in_amount),
                    history_transfer_in_cost: Ok(value.history_transfer_in_cost),
                    history_transfer_out_amount: Ok(value.history_transfer_out_amount),
                    history_transfer_out_income: Ok(value.history_transfer_out_income),
                    is_closed: Ok(value.is_closed),
                    is_transfer_in: Ok(value.is_transfer_in),
                    last_active_at: Ok(value.last_active_at),
                    loss_count: Ok(value.loss_count),
                    maker_token_tags: Ok(value.maker_token_tags),
                    native_balance: Ok(value.native_balance),
                    netflow_usd: Ok(value.netflow_usd),
                    percentage: Ok(value.percentage),
                    position_cost_usd: Ok(value.position_cost_usd),
                    realized_pnl_ratio: Ok(value.realized_pnl_ratio),
                    realized_profit: Ok(value.realized_profit),
                    roi: Ok(value.roi),
                    sell_amount_cur: Ok(value.sell_amount_cur),
                    sell_amount_percentage: Ok(value.sell_amount_percentage),
                    sell_volume_native: Ok(value.sell_volume_native),
                    sell_volume_usd: Ok(value.sell_volume_usd),
                    start_holding_at: Ok(value.start_holding_at),
                    tags: Ok(value.tags),
                    total_buy_count: Ok(value.total_buy_count),
                    total_cost_usd: Ok(value.total_cost_usd),
                    total_profit: Ok(value.total_profit),
                    total_sell_count: Ok(value.total_sell_count),
                    transfer_in_amount7d: Ok(value.transfer_in_amount7d),
                    transfer_in_count: Ok(value.transfer_in_count),
                    transfer_out_amount7d: Ok(value.transfer_out_amount7d),
                    transfer_out_count: Ok(value.transfer_out_count),
                    unrealized_profit: Ok(value.unrealized_profit),
                    wallet_address: Ok(value.wallet_address),
                    wallet_tag_v2: Ok(value.wallet_tag_v2),
                    win_count: Ok(value.win_count),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct PageResponseTokenLiquiditySnapshot {
            data: ::std::result::Result<
                ::std::vec::Vec<super::PageResponseTokenLiquiditySnapshotDataItem>,
                ::std::string::String,
            >,
            end_cursor: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            has_next: ::std::result::Result<
                ::std::option::Option<bool>,
                ::std::string::String,
            >,
            has_prev: ::std::result::Result<
                ::std::option::Option<bool>,
                ::std::string::String,
            >,
            start_cursor: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for PageResponseTokenLiquiditySnapshot {
            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()),
                }
            }
        }
        impl PageResponseTokenLiquiditySnapshot {
            pub fn data<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<
                    ::std::vec::Vec<super::PageResponseTokenLiquiditySnapshotDataItem>,
                >,
                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<::std::option::Option<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<::std::option::Option<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<PageResponseTokenLiquiditySnapshot>
        for super::PageResponseTokenLiquiditySnapshot {
            type Error = super::error::ConversionError;
            fn try_from(
                value: PageResponseTokenLiquiditySnapshot,
            ) -> ::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::PageResponseTokenLiquiditySnapshot>
        for PageResponseTokenLiquiditySnapshot {
            fn from(value: super::PageResponseTokenLiquiditySnapshot) -> 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 PageResponseTokenLiquiditySnapshotDataItem {
            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 PageResponseTokenLiquiditySnapshotDataItem {
            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 PageResponseTokenLiquiditySnapshotDataItem {
            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<PageResponseTokenLiquiditySnapshotDataItem>
        for super::PageResponseTokenLiquiditySnapshotDataItem {
            type Error = super::error::ConversionError;
            fn try_from(
                value: PageResponseTokenLiquiditySnapshotDataItem,
            ) -> ::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::PageResponseTokenLiquiditySnapshotDataItem>
        for PageResponseTokenLiquiditySnapshotDataItem {
            fn from(value: super::PageResponseTokenLiquiditySnapshotDataItem) -> 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 PageResponseTokenMintBurn {
            data: ::std::result::Result<
                ::std::vec::Vec<super::PageResponseTokenMintBurnDataItem>,
                ::std::string::String,
            >,
            end_cursor: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            has_next: ::std::result::Result<
                ::std::option::Option<bool>,
                ::std::string::String,
            >,
            has_prev: ::std::result::Result<
                ::std::option::Option<bool>,
                ::std::string::String,
            >,
            start_cursor: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for PageResponseTokenMintBurn {
            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()),
                }
            }
        }
        impl PageResponseTokenMintBurn {
            pub fn data<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<
                    ::std::vec::Vec<super::PageResponseTokenMintBurnDataItem>,
                >,
                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<::std::option::Option<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<::std::option::Option<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<PageResponseTokenMintBurn>
        for super::PageResponseTokenMintBurn {
            type Error = super::error::ConversionError;
            fn try_from(
                value: PageResponseTokenMintBurn,
            ) -> ::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::PageResponseTokenMintBurn>
        for PageResponseTokenMintBurn {
            fn from(value: super::PageResponseTokenMintBurn) -> 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 PageResponseTokenMintBurnDataItem {
            amount: ::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>,
            mint_burn_type: ::std::result::Result<
                super::MintBurnType,
                ::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,
            >,
        }
        impl ::std::default::Default for PageResponseTokenMintBurnDataItem {
            fn default() -> Self {
                Self {
                    amount: Err("no value supplied for amount".to_string()),
                    block_height: Err("no value supplied for block_height".to_string()),
                    block_timestamp: Err(
                        "no value supplied for block_timestamp".to_string(),
                    ),
                    mint_burn_type: Err(
                        "no value supplied for mint_burn_type".to_string(),
                    ),
                    token_address: Err(
                        "no value supplied for token_address".to_string(),
                    ),
                    transaction_signature: Err(
                        "no value supplied for transaction_signature".to_string(),
                    ),
                }
            }
        }
        impl PageResponseTokenMintBurnDataItem {
            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_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 mint_burn_type<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<super::MintBurnType>,
                T::Error: ::std::fmt::Display,
            {
                self.mint_burn_type = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for mint_burn_type: {}", 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
            }
        }
        impl ::std::convert::TryFrom<PageResponseTokenMintBurnDataItem>
        for super::PageResponseTokenMintBurnDataItem {
            type Error = super::error::ConversionError;
            fn try_from(
                value: PageResponseTokenMintBurnDataItem,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    amount: value.amount?,
                    block_height: value.block_height?,
                    block_timestamp: value.block_timestamp?,
                    mint_burn_type: value.mint_burn_type?,
                    token_address: value.token_address?,
                    transaction_signature: value.transaction_signature?,
                })
            }
        }
        impl ::std::convert::From<super::PageResponseTokenMintBurnDataItem>
        for PageResponseTokenMintBurnDataItem {
            fn from(value: super::PageResponseTokenMintBurnDataItem) -> Self {
                Self {
                    amount: Ok(value.amount),
                    block_height: Ok(value.block_height),
                    block_timestamp: Ok(value.block_timestamp),
                    mint_burn_type: Ok(value.mint_burn_type),
                    token_address: Ok(value.token_address),
                    transaction_signature: Ok(value.transaction_signature),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct PageResponseTokenPrice {
            data: ::std::result::Result<
                ::std::vec::Vec<super::PageResponseTokenPriceDataItem>,
                ::std::string::String,
            >,
            end_cursor: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            has_next: ::std::result::Result<
                ::std::option::Option<bool>,
                ::std::string::String,
            >,
            has_prev: ::std::result::Result<
                ::std::option::Option<bool>,
                ::std::string::String,
            >,
            start_cursor: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for PageResponseTokenPrice {
            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()),
                }
            }
        }
        impl PageResponseTokenPrice {
            pub fn data<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<
                    ::std::vec::Vec<super::PageResponseTokenPriceDataItem>,
                >,
                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<::std::option::Option<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<::std::option::Option<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<PageResponseTokenPrice>
        for super::PageResponseTokenPrice {
            type Error = super::error::ConversionError;
            fn try_from(
                value: PageResponseTokenPrice,
            ) -> ::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::PageResponseTokenPrice>
        for PageResponseTokenPrice {
            fn from(value: super::PageResponseTokenPrice) -> 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 PageResponseTokenPriceDataItem {
            address: ::std::result::Result<::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,
            >,
            timestamp: ::std::result::Result<i64, ::std::string::String>,
        }
        impl ::std::default::Default for PageResponseTokenPriceDataItem {
            fn default() -> Self {
                Self {
                    address: Err("no value supplied for address".to_string()),
                    price_in_sol: Ok(Default::default()),
                    price_in_usd: Err("no value supplied for price_in_usd".to_string()),
                    timestamp: Err("no value supplied for timestamp".to_string()),
                }
            }
        }
        impl PageResponseTokenPriceDataItem {
            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 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 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
            }
        }
        impl ::std::convert::TryFrom<PageResponseTokenPriceDataItem>
        for super::PageResponseTokenPriceDataItem {
            type Error = super::error::ConversionError;
            fn try_from(
                value: PageResponseTokenPriceDataItem,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    address: value.address?,
                    price_in_sol: value.price_in_sol?,
                    price_in_usd: value.price_in_usd?,
                    timestamp: value.timestamp?,
                })
            }
        }
        impl ::std::convert::From<super::PageResponseTokenPriceDataItem>
        for PageResponseTokenPriceDataItem {
            fn from(value: super::PageResponseTokenPriceDataItem) -> Self {
                Self {
                    address: Ok(value.address),
                    price_in_sol: Ok(value.price_in_sol),
                    price_in_usd: Ok(value.price_in_usd),
                    timestamp: Ok(value.timestamp),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct PageResponseTokenTrader {
            data: ::std::result::Result<
                ::std::vec::Vec<super::PageResponseTokenTraderDataItem>,
                ::std::string::String,
            >,
            end_cursor: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            has_next: ::std::result::Result<
                ::std::option::Option<bool>,
                ::std::string::String,
            >,
            has_prev: ::std::result::Result<
                ::std::option::Option<bool>,
                ::std::string::String,
            >,
            start_cursor: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for PageResponseTokenTrader {
            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()),
                }
            }
        }
        impl PageResponseTokenTrader {
            pub fn data<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<
                    ::std::vec::Vec<super::PageResponseTokenTraderDataItem>,
                >,
                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<::std::option::Option<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<::std::option::Option<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<PageResponseTokenTrader>
        for super::PageResponseTokenTrader {
            type Error = super::error::ConversionError;
            fn try_from(
                value: PageResponseTokenTrader,
            ) -> ::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::PageResponseTokenTrader>
        for PageResponseTokenTrader {
            fn from(value: super::PageResponseTokenTrader) -> 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 PageResponseTokenTraderDataItem {
            address: ::std::result::Result<::std::string::String, ::std::string::String>,
            block_timestamp: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            onchain_created_at: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::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 PageResponseTokenTraderDataItem {
            fn default() -> Self {
                Self {
                    address: Err("no value supplied for address".to_string()),
                    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 PageResponseTokenTraderDataItem {
            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_timestamp<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                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<::std::option::Option<::std::string::String>>,
                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<PageResponseTokenTraderDataItem>
        for super::PageResponseTokenTraderDataItem {
            type Error = super::error::ConversionError;
            fn try_from(
                value: PageResponseTokenTraderDataItem,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    address: value.address?,
                    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::PageResponseTokenTraderDataItem>
        for PageResponseTokenTraderDataItem {
            fn from(value: super::PageResponseTokenTraderDataItem) -> Self {
                Self {
                    address: Ok(value.address),
                    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 PageResponseTokenTransfer {
            data: ::std::result::Result<
                ::std::vec::Vec<super::PageResponseTokenTransferDataItem>,
                ::std::string::String,
            >,
            end_cursor: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            has_next: ::std::result::Result<
                ::std::option::Option<bool>,
                ::std::string::String,
            >,
            has_prev: ::std::result::Result<
                ::std::option::Option<bool>,
                ::std::string::String,
            >,
            start_cursor: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for PageResponseTokenTransfer {
            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()),
                }
            }
        }
        impl PageResponseTokenTransfer {
            pub fn data<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<
                    ::std::vec::Vec<super::PageResponseTokenTransferDataItem>,
                >,
                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<::std::option::Option<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<::std::option::Option<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<PageResponseTokenTransfer>
        for super::PageResponseTokenTransfer {
            type Error = super::error::ConversionError;
            fn try_from(
                value: PageResponseTokenTransfer,
            ) -> ::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::PageResponseTokenTransfer>
        for PageResponseTokenTransfer {
            fn from(value: super::PageResponseTokenTransfer) -> 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 PageResponseTokenTransferDataItem {
            amount: ::std::result::Result<::std::string::String, ::std::string::String>,
            amount_in_usd: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            block_timestamp: ::std::result::Result<i64, ::std::string::String>,
            from_address: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            id: ::std::result::Result<::std::string::String, ::std::string::String>,
            status: ::std::result::Result<::std::string::String, ::std::string::String>,
            to_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<::std::string::String, ::std::string::String>,
        }
        impl ::std::default::Default for PageResponseTokenTransferDataItem {
            fn default() -> Self {
                Self {
                    amount: Err("no value supplied for amount".to_string()),
                    amount_in_usd: Ok(Default::default()),
                    block_timestamp: Err(
                        "no value supplied for block_timestamp".to_string(),
                    ),
                    from_address: Err("no value supplied for from_address".to_string()),
                    id: Err("no value supplied for id".to_string()),
                    status: Err("no value supplied for status".to_string()),
                    to_address: Err("no value supplied for to_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 PageResponseTokenTransferDataItem {
            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::option::Option<::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 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 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 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 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 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 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<::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<PageResponseTokenTransferDataItem>
        for super::PageResponseTokenTransferDataItem {
            type Error = super::error::ConversionError;
            fn try_from(
                value: PageResponseTokenTransferDataItem,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    amount: value.amount?,
                    amount_in_usd: value.amount_in_usd?,
                    block_timestamp: value.block_timestamp?,
                    from_address: value.from_address?,
                    id: value.id?,
                    status: value.status?,
                    to_address: value.to_address?,
                    token_address: value.token_address?,
                    transaction_signature: value.transaction_signature?,
                    type_: value.type_?,
                })
            }
        }
        impl ::std::convert::From<super::PageResponseTokenTransferDataItem>
        for PageResponseTokenTransferDataItem {
            fn from(value: super::PageResponseTokenTransferDataItem) -> Self {
                Self {
                    amount: Ok(value.amount),
                    amount_in_usd: Ok(value.amount_in_usd),
                    block_timestamp: Ok(value.block_timestamp),
                    from_address: Ok(value.from_address),
                    id: Ok(value.id),
                    status: Ok(value.status),
                    to_address: Ok(value.to_address),
                    token_address: Ok(value.token_address),
                    transaction_signature: Ok(value.transaction_signature),
                    type_: Ok(value.type_),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct PageResponseTopTrader {
            data: ::std::result::Result<
                ::std::vec::Vec<super::PageResponseTopTraderDataItem>,
                ::std::string::String,
            >,
            end_cursor: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            has_next: ::std::result::Result<
                ::std::option::Option<bool>,
                ::std::string::String,
            >,
            has_prev: ::std::result::Result<
                ::std::option::Option<bool>,
                ::std::string::String,
            >,
            start_cursor: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for PageResponseTopTrader {
            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()),
                }
            }
        }
        impl PageResponseTopTrader {
            pub fn data<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<
                    ::std::vec::Vec<super::PageResponseTopTraderDataItem>,
                >,
                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<::std::option::Option<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<::std::option::Option<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<PageResponseTopTrader>
        for super::PageResponseTopTrader {
            type Error = super::error::ConversionError;
            fn try_from(
                value: PageResponseTopTrader,
            ) -> ::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::PageResponseTopTrader>
        for PageResponseTopTrader {
            fn from(value: super::PageResponseTopTrader) -> 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 PageResponseTopTraderDataItem {
            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 PageResponseTopTraderDataItem {
            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 PageResponseTopTraderDataItem {
            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<PageResponseTopTraderDataItem>
        for super::PageResponseTopTraderDataItem {
            type Error = super::error::ConversionError;
            fn try_from(
                value: PageResponseTopTraderDataItem,
            ) -> ::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::PageResponseTopTraderDataItem>
        for PageResponseTopTraderDataItem {
            fn from(value: super::PageResponseTopTraderDataItem) -> 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 PageResponseTradeDetail {
            data: ::std::result::Result<
                ::std::vec::Vec<super::PageResponseTradeDetailDataItem>,
                ::std::string::String,
            >,
            end_cursor: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            has_next: ::std::result::Result<
                ::std::option::Option<bool>,
                ::std::string::String,
            >,
            has_prev: ::std::result::Result<
                ::std::option::Option<bool>,
                ::std::string::String,
            >,
            start_cursor: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for PageResponseTradeDetail {
            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()),
                }
            }
        }
        impl PageResponseTradeDetail {
            pub fn data<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<
                    ::std::vec::Vec<super::PageResponseTradeDetailDataItem>,
                >,
                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<::std::option::Option<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<::std::option::Option<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<PageResponseTradeDetail>
        for super::PageResponseTradeDetail {
            type Error = super::error::ConversionError;
            fn try_from(
                value: PageResponseTradeDetail,
            ) -> ::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::PageResponseTradeDetail>
        for PageResponseTradeDetail {
            fn from(value: super::PageResponseTradeDetail) -> 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 PageResponseTradeDetailDataItem {
            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::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            dex_program_address: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            dex_protocol_family: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            gas_fee: ::std::result::Result<
                ::std::option::Option<i64>,
                ::std::string::String,
            >,
            gas_fee_in_native: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            gas_fee_in_usd: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            history_bought_amount: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            history_sold_amount: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            is_open_or_close: ::std::result::Result<
                ::std::option::Option<i32>,
                ::std::string::String,
            >,
            maker_event_tags: ::std::result::Result<
                ::std::vec::Vec<::std::string::String>,
                ::std::string::String,
            >,
            market_cap_in_usd: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            pool_address: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            post_balance: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            realized_profit_in_usd: ::std::result::Result<
                ::std::option::Option<::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::option::Option<::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::option::Option<::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,
            >,
            trader_tags: ::std::result::Result<
                ::std::vec::Vec<::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 PageResponseTradeDetailDataItem {
            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: Ok(Default::default()),
                    dex_program_address: Ok(Default::default()),
                    dex_protocol_family: Ok(Default::default()),
                    gas_fee: Ok(Default::default()),
                    gas_fee_in_native: Ok(Default::default()),
                    gas_fee_in_usd: Ok(Default::default()),
                    history_bought_amount: Ok(Default::default()),
                    history_sold_amount: Ok(Default::default()),
                    is_open_or_close: Ok(Default::default()),
                    maker_event_tags: Ok(Default::default()),
                    market_cap_in_usd: Ok(Default::default()),
                    pool_address: Err("no value supplied for pool_address".to_string()),
                    post_balance: Ok(Default::default()),
                    realized_profit_in_usd: Ok(Default::default()),
                    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: Ok(Default::default()),
                    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: Ok(Default::default()),
                    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()),
                    trader_tags: Ok(Default::default()),
                    transaction_signature: Err(
                        "no value supplied for transaction_signature".to_string(),
                    ),
                    type_: Err("no value supplied for type_".to_string()),
                }
            }
        }
        impl PageResponseTradeDetailDataItem {
            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::option::Option<::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::option::Option<::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::option::Option<::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 gas_fee<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<i64>>,
                T::Error: ::std::fmt::Display,
            {
                self.gas_fee = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for gas_fee: {}", e)
                    });
                self
            }
            pub fn gas_fee_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.gas_fee_in_native = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for gas_fee_in_native: {}",
                            e
                        )
                    });
                self
            }
            pub fn gas_fee_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.gas_fee_in_usd = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for gas_fee_in_usd: {}", e
                        )
                    });
                self
            }
            pub fn history_bought_amount<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.history_bought_amount = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for history_bought_amount: {}",
                            e
                        )
                    });
                self
            }
            pub fn history_sold_amount<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.history_sold_amount = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for history_sold_amount: {}",
                            e
                        )
                    });
                self
            }
            pub fn is_open_or_close<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<i32>>,
                T::Error: ::std::fmt::Display,
            {
                self.is_open_or_close = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for is_open_or_close: {}", e
                        )
                    });
                self
            }
            pub fn maker_event_tags<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::vec::Vec<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.maker_event_tags = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for maker_event_tags: {}", e
                        )
                    });
                self
            }
            pub fn market_cap_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.market_cap_in_usd = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for market_cap_in_usd: {}",
                            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 post_balance<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::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 realized_profit_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.realized_profit_in_usd = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for realized_profit_in_usd: {}",
                            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::option::Option<::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::option::Option<::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 trader_tags<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::vec::Vec<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.trader_tags = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for trader_tags: {}", 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<PageResponseTradeDetailDataItem>
        for super::PageResponseTradeDetailDataItem {
            type Error = super::error::ConversionError;
            fn try_from(
                value: PageResponseTradeDetailDataItem,
            ) -> ::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?,
                    gas_fee: value.gas_fee?,
                    gas_fee_in_native: value.gas_fee_in_native?,
                    gas_fee_in_usd: value.gas_fee_in_usd?,
                    history_bought_amount: value.history_bought_amount?,
                    history_sold_amount: value.history_sold_amount?,
                    is_open_or_close: value.is_open_or_close?,
                    maker_event_tags: value.maker_event_tags?,
                    market_cap_in_usd: value.market_cap_in_usd?,
                    pool_address: value.pool_address?,
                    post_balance: value.post_balance?,
                    realized_profit_in_usd: value.realized_profit_in_usd?,
                    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?,
                    trader_tags: value.trader_tags?,
                    transaction_signature: value.transaction_signature?,
                    type_: value.type_?,
                })
            }
        }
        impl ::std::convert::From<super::PageResponseTradeDetailDataItem>
        for PageResponseTradeDetailDataItem {
            fn from(value: super::PageResponseTradeDetailDataItem) -> 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),
                    gas_fee: Ok(value.gas_fee),
                    gas_fee_in_native: Ok(value.gas_fee_in_native),
                    gas_fee_in_usd: Ok(value.gas_fee_in_usd),
                    history_bought_amount: Ok(value.history_bought_amount),
                    history_sold_amount: Ok(value.history_sold_amount),
                    is_open_or_close: Ok(value.is_open_or_close),
                    maker_event_tags: Ok(value.maker_event_tags),
                    market_cap_in_usd: Ok(value.market_cap_in_usd),
                    pool_address: Ok(value.pool_address),
                    post_balance: Ok(value.post_balance),
                    realized_profit_in_usd: Ok(value.realized_profit_in_usd),
                    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),
                    trader_tags: Ok(value.trader_tags),
                    transaction_signature: Ok(value.transaction_signature),
                    type_: Ok(value.type_),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct PageResponseTraderGainersLosersItem {
            data: ::std::result::Result<
                ::std::vec::Vec<super::PageResponseTraderGainersLosersItemDataItem>,
                ::std::string::String,
            >,
            end_cursor: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            has_next: ::std::result::Result<
                ::std::option::Option<bool>,
                ::std::string::String,
            >,
            has_prev: ::std::result::Result<
                ::std::option::Option<bool>,
                ::std::string::String,
            >,
            start_cursor: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for PageResponseTraderGainersLosersItem {
            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()),
                }
            }
        }
        impl PageResponseTraderGainersLosersItem {
            pub fn data<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<
                    ::std::vec::Vec<super::PageResponseTraderGainersLosersItemDataItem>,
                >,
                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<::std::option::Option<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<::std::option::Option<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<PageResponseTraderGainersLosersItem>
        for super::PageResponseTraderGainersLosersItem {
            type Error = super::error::ConversionError;
            fn try_from(
                value: PageResponseTraderGainersLosersItem,
            ) -> ::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::PageResponseTraderGainersLosersItem>
        for PageResponseTraderGainersLosersItem {
            fn from(value: super::PageResponseTraderGainersLosersItem) -> 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 PageResponseTraderGainersLosersItemDataItem {
            address: ::std::result::Result<::std::string::String, ::std::string::String>,
            chain: ::std::result::Result<::std::string::String, ::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 PageResponseTraderGainersLosersItemDataItem {
            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 PageResponseTraderGainersLosersItemDataItem {
            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 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<PageResponseTraderGainersLosersItemDataItem>
        for super::PageResponseTraderGainersLosersItemDataItem {
            type Error = super::error::ConversionError;
            fn try_from(
                value: PageResponseTraderGainersLosersItemDataItem,
            ) -> ::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::PageResponseTraderGainersLosersItemDataItem>
        for PageResponseTraderGainersLosersItemDataItem {
            fn from(value: super::PageResponseTraderGainersLosersItemDataItem) -> 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 PageResponseWalletTransfer {
            data: ::std::result::Result<
                ::std::vec::Vec<super::PageResponseWalletTransferDataItem>,
                ::std::string::String,
            >,
            end_cursor: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            has_next: ::std::result::Result<
                ::std::option::Option<bool>,
                ::std::string::String,
            >,
            has_prev: ::std::result::Result<
                ::std::option::Option<bool>,
                ::std::string::String,
            >,
            start_cursor: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for PageResponseWalletTransfer {
            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()),
                }
            }
        }
        impl PageResponseWalletTransfer {
            pub fn data<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<
                    ::std::vec::Vec<super::PageResponseWalletTransferDataItem>,
                >,
                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<::std::option::Option<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<::std::option::Option<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<PageResponseWalletTransfer>
        for super::PageResponseWalletTransfer {
            type Error = super::error::ConversionError;
            fn try_from(
                value: PageResponseWalletTransfer,
            ) -> ::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::PageResponseWalletTransfer>
        for PageResponseWalletTransfer {
            fn from(value: super::PageResponseWalletTransfer) -> 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 PageResponseWalletTransferDataItem {
            amount: ::std::result::Result<::std::string::String, ::std::string::String>,
            amount_in_usd: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            block_timestamp: ::std::result::Result<i64, ::std::string::String>,
            from_address: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            id: ::std::result::Result<::std::string::String, ::std::string::String>,
            to_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,
            >,
            transfer_type: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for PageResponseWalletTransferDataItem {
            fn default() -> Self {
                Self {
                    amount: Err("no value supplied for amount".to_string()),
                    amount_in_usd: Ok(Default::default()),
                    block_timestamp: Err(
                        "no value supplied for block_timestamp".to_string(),
                    ),
                    from_address: Err("no value supplied for from_address".to_string()),
                    id: Err("no value supplied for id".to_string()),
                    to_address: Err("no value supplied for to_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(),
                    ),
                    transfer_type: Err("no value supplied for transfer_type".to_string()),
                }
            }
        }
        impl PageResponseWalletTransferDataItem {
            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::option::Option<::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 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 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 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 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 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 transfer_type<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.transfer_type = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for transfer_type: {}", e
                        )
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<PageResponseWalletTransferDataItem>
        for super::PageResponseWalletTransferDataItem {
            type Error = super::error::ConversionError;
            fn try_from(
                value: PageResponseWalletTransferDataItem,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    amount: value.amount?,
                    amount_in_usd: value.amount_in_usd?,
                    block_timestamp: value.block_timestamp?,
                    from_address: value.from_address?,
                    id: value.id?,
                    to_address: value.to_address?,
                    token_address: value.token_address?,
                    transaction_signature: value.transaction_signature?,
                    transfer_type: value.transfer_type?,
                })
            }
        }
        impl ::std::convert::From<super::PageResponseWalletTransferDataItem>
        for PageResponseWalletTransferDataItem {
            fn from(value: super::PageResponseWalletTransferDataItem) -> Self {
                Self {
                    amount: Ok(value.amount),
                    amount_in_usd: Ok(value.amount_in_usd),
                    block_timestamp: Ok(value.block_timestamp),
                    from_address: Ok(value.from_address),
                    id: Ok(value.id),
                    to_address: Ok(value.to_address),
                    token_address: Ok(value.token_address),
                    transaction_signature: Ok(value.transaction_signature),
                    transfer_type: Ok(value.transfer_type),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct PnlDetailItem {
            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<
                ::std::option::Option<i32>,
                ::std::string::String,
            >,
            first_buy_at: ::std::result::Result<
                ::std::option::Option<i64>,
                ::std::string::String,
            >,
            is_closed: ::std::result::Result<bool, ::std::string::String>,
            last_sell_at: ::std::result::Result<
                ::std::option::Option<i64>,
                ::std::string::String,
            >,
            logo_uri: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            losses: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            name: ::std::result::Result<
                ::std::option::Option<::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::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            token_address: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            total_cost_in_usd: ::std::result::Result<
                ::std::option::Option<::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,
            >,
            wins: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for PnlDetailItem {
            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: Ok(Default::default()),
                    first_buy_at: Ok(Default::default()),
                    is_closed: Err("no value supplied for is_closed".to_string()),
                    last_sell_at: Ok(Default::default()),
                    logo_uri: Ok(Default::default()),
                    losses: Ok(Default::default()),
                    name: Ok(Default::default()),
                    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: Ok(Default::default()),
                    token_address: Err(
                        "no value supplied for token_address".to_string(),
                    ),
                    total_cost_in_usd: Ok(Default::default()),
                    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(),
                    ),
                    wins: Ok(Default::default()),
                }
            }
        }
        impl PnlDetailItem {
            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<::std::option::Option<i32>>,
                T::Error: ::std::fmt::Display,
            {
                self.decimals = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for decimals: {}", e)
                    });
                self
            }
            pub fn first_buy_at<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<i64>>,
                T::Error: ::std::fmt::Display,
            {
                self.first_buy_at = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for first_buy_at: {}", e
                        )
                    });
                self
            }
            pub fn is_closed<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<bool>,
                T::Error: ::std::fmt::Display,
            {
                self.is_closed = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for is_closed: {}", e)
                    });
                self
            }
            pub fn last_sell_at<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<i64>>,
                T::Error: ::std::fmt::Display,
            {
                self.last_sell_at = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for last_sell_at: {}", 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 losses<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::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 name<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::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::option::Option<::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_cost_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.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 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 wins<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::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<PnlDetailItem> for super::PnlDetailItem {
            type Error = super::error::ConversionError;
            fn try_from(
                value: PnlDetailItem,
            ) -> ::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?,
                    first_buy_at: value.first_buy_at?,
                    is_closed: value.is_closed?,
                    last_sell_at: value.last_sell_at?,
                    logo_uri: value.logo_uri?,
                    losses: value.losses?,
                    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_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?,
                    wallet_address: value.wallet_address?,
                    wins: value.wins?,
                })
            }
        }
        impl ::std::convert::From<super::PnlDetailItem> for PnlDetailItem {
            fn from(value: super::PnlDetailItem) -> 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),
                    first_buy_at: Ok(value.first_buy_at),
                    is_closed: Ok(value.is_closed),
                    last_sell_at: Ok(value.last_sell_at),
                    logo_uri: Ok(value.logo_uri),
                    losses: Ok(value.losses),
                    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_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),
                    wallet_address: Ok(value.wallet_address),
                    wins: Ok(value.wins),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct PnlDetailSummary {
            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 PnlDetailSummary {
            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 PnlDetailSummary {
            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<PnlDetailSummary> for super::PnlDetailSummary {
            type Error = super::error::ConversionError;
            fn try_from(
                value: PnlDetailSummary,
            ) -> ::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::PnlDetailSummary> for PnlDetailSummary {
            fn from(value: super::PnlDetailSummary) -> 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 PnlDetailsResult {
            data: ::std::result::Result<
                ::std::vec::Vec<super::PnlDetailItem>,
                ::std::string::String,
            >,
            end_cursor: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            has_next: ::std::result::Result<
                ::std::option::Option<bool>,
                ::std::string::String,
            >,
            has_prev: ::std::result::Result<
                ::std::option::Option<bool>,
                ::std::string::String,
            >,
            start_cursor: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            summary: ::std::result::Result<
                super::PnlDetailSummary,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for PnlDetailsResult {
            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()),
                }
            }
        }
        impl PnlDetailsResult {
            pub fn data<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::vec::Vec<super::PnlDetailItem>>,
                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<::std::option::Option<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<::std::option::Option<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::PnlDetailSummary>,
                T::Error: ::std::fmt::Display,
            {
                self.summary = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for summary: {}", e)
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<PnlDetailsResult> for super::PnlDetailsResult {
            type Error = super::error::ConversionError;
            fn try_from(
                value: PnlDetailsResult,
            ) -> ::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?,
                })
            }
        }
        impl ::std::convert::From<super::PnlDetailsResult> for PnlDetailsResult {
            fn from(value: super::PnlDetailsResult) -> 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),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct PresignResponseModel {
            presign_url: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for PresignResponseModel {
            fn default() -> Self {
                Self {
                    presign_url: Err("no value supplied for presign_url".to_string()),
                }
            }
        }
        impl PresignResponseModel {
            pub fn presign_url<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.presign_url = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for presign_url: {}", e)
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<PresignResponseModel>
        for super::PresignResponseModel {
            type Error = super::error::ConversionError;
            fn try_from(
                value: PresignResponseModel,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    presign_url: value.presign_url?,
                })
            }
        }
        impl ::std::convert::From<super::PresignResponseModel> for PresignResponseModel {
            fn from(value: super::PresignResponseModel) -> Self {
                Self {
                    presign_url: Ok(value.presign_url),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct RangeFilterCondition {
            field: ::std::result::Result<::std::string::String, ::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 RangeFilterCondition {
            fn default() -> Self {
                Self {
                    field: Err("no value supplied for field".to_string()),
                    max: Ok(Default::default()),
                    min: Ok(Default::default()),
                }
            }
        }
        impl RangeFilterCondition {
            pub fn field<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                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<RangeFilterCondition>
        for super::RangeFilterCondition {
            type Error = super::error::ConversionError;
            fn try_from(
                value: RangeFilterCondition,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    field: value.field?,
                    max: value.max?,
                    min: value.min?,
                })
            }
        }
        impl ::std::convert::From<super::RangeFilterCondition> for RangeFilterCondition {
            fn from(value: super::RangeFilterCondition) -> Self {
                Self {
                    field: Ok(value.field),
                    max: Ok(value.max),
                    min: Ok(value.min),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct RedPacket {
            chain: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            claim_authority: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            claimed_amount: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            claimed_count: ::std::result::Result<
                ::std::option::Option<i32>,
                ::std::string::String,
            >,
            created_at: ::std::result::Result<
                ::std::option::Option<i64>,
                ::std::string::String,
            >,
            creator: ::std::result::Result<::std::string::String, ::std::string::String>,
            expiration: ::std::result::Result<
                ::std::option::Option<i64>,
                ::std::string::String,
            >,
            expired: ::std::result::Result<
                ::std::option::Option<bool>,
                ::std::string::String,
            >,
            expired_at: ::std::result::Result<
                ::std::option::Option<i64>,
                ::std::string::String,
            >,
            id: ::std::result::Result<::std::string::String, ::std::string::String>,
            max_claims: ::std::result::Result<i32, ::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>,
            refunded_amount: ::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,
            >,
            total_amount: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            tx_hash: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for RedPacket {
            fn default() -> Self {
                Self {
                    chain: Ok(Default::default()),
                    claim_authority: Ok(Default::default()),
                    claimed_amount: Ok(Default::default()),
                    claimed_count: Ok(Default::default()),
                    created_at: Ok(Default::default()),
                    creator: Err("no value supplied for creator".to_string()),
                    expiration: Ok(Default::default()),
                    expired: Ok(Default::default()),
                    expired_at: Ok(Default::default()),
                    id: Err("no value supplied for id".to_string()),
                    max_claims: Err("no value supplied for max_claims".to_string()),
                    memo: Ok(Default::default()),
                    mint: Err("no value supplied for mint".to_string()),
                    refunded_amount: Ok(Default::default()),
                    share_id: Ok(Default::default()),
                    total_amount: Err("no value supplied for total_amount".to_string()),
                    tx_hash: Ok(Default::default()),
                }
            }
        }
        impl RedPacket {
            pub fn chain<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::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 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 claimed_amount<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::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<::std::option::Option<i32>>,
                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<::std::option::Option<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<::std::option::Option<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<::std::option::Option<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<::std::option::Option<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<i32>,
                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 refunded_amount<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::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::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
            }
            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::option::Option<::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<RedPacket> for super::RedPacket {
            type Error = super::error::ConversionError;
            fn try_from(
                value: RedPacket,
            ) -> ::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::RedPacket> for RedPacket {
            fn from(value: super::RedPacket) -> 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 RedPacketClaim {
            amount: ::std::result::Result<::std::string::String, ::std::string::String>,
            chain: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            claimed_at: ::std::result::Result<
                ::std::option::Option<i64>,
                ::std::string::String,
            >,
            claimer: ::std::result::Result<::std::string::String, ::std::string::String>,
            creator: ::std::result::Result<
                ::std::option::Option<::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::option::Option<::std::string::String>,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for RedPacketClaim {
            fn default() -> Self {
                Self {
                    amount: Err("no value supplied for amount".to_string()),
                    chain: Ok(Default::default()),
                    claimed_at: Ok(Default::default()),
                    claimer: Err("no value supplied for claimer".to_string()),
                    creator: Ok(Default::default()),
                    mint: Err("no value supplied for mint".to_string()),
                    packet_id: Err("no value supplied for packet_id".to_string()),
                    tx_hash: Ok(Default::default()),
                }
            }
        }
        impl RedPacketClaim {
            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::option::Option<::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 claimed_at<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<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::option::Option<::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::option::Option<::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<RedPacketClaim> for super::RedPacketClaim {
            type Error = super::error::ConversionError;
            fn try_from(
                value: RedPacketClaim,
            ) -> ::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::RedPacketClaim> for RedPacketClaim {
            fn from(value: super::RedPacketClaim) -> 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::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            has_next_page: ::std::result::Result<bool, ::std::string::String>,
            records: ::std::result::Result<
                ::std::vec::Vec<super::RedPacketClaim>,
                ::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 RedPacketClaimsPage {
            fn default() -> Self {
                Self {
                    end_cursor: Ok(Default::default()),
                    has_next_page: Err(
                        "no value supplied for has_next_page".to_string(),
                    ),
                    records: Err("no value supplied for records".to_string()),
                    start_cursor: Ok(Default::default()),
                    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::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_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::RedPacketClaim>>,
                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::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<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 RedPacketSendTxRequest {
            signed_tx: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for RedPacketSendTxRequest {
            fn default() -> Self {
                Self {
                    signed_tx: Err("no value supplied for signed_tx".to_string()),
                }
            }
        }
        impl RedPacketSendTxRequest {
            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<RedPacketSendTxRequest>
        for super::RedPacketSendTxRequest {
            type Error = super::error::ConversionError;
            fn try_from(
                value: RedPacketSendTxRequest,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    signed_tx: value.signed_tx?,
                })
            }
        }
        impl ::std::convert::From<super::RedPacketSendTxRequest>
        for RedPacketSendTxRequest {
            fn from(value: super::RedPacketSendTxRequest) -> 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::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            has_next_page: ::std::result::Result<bool, ::std::string::String>,
            records: ::std::result::Result<
                ::std::vec::Vec<super::RedPacket>,
                ::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 RedPacketsPage {
            fn default() -> Self {
                Self {
                    end_cursor: Ok(Default::default()),
                    has_next_page: Err(
                        "no value supplied for has_next_page".to_string(),
                    ),
                    records: Err("no value supplied for records".to_string()),
                    start_cursor: Ok(Default::default()),
                    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::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_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::RedPacket>>,
                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::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<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 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 SerializedSecurityInfo {
            available: ::std::result::Result<bool, ::std::string::String>,
            chain_supported: ::std::result::Result<
                ::std::option::Option<bool>,
                ::std::string::String,
            >,
            is_open_source: ::std::result::Result<
                ::std::option::Option<bool>,
                ::std::string::String,
            >,
            is_proxy: ::std::result::Result<
                ::std::option::Option<bool>,
                ::std::string::String,
            >,
            is_renounced: ::std::result::Result<
                ::std::option::Option<bool>,
                ::std::string::String,
            >,
            is_safe: ::std::result::Result<
                ::std::option::Option<bool>,
                ::std::string::String,
            >,
            last_refreshed_at: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            launchpad_name: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            owner_address: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            raw: ::std::result::Result<
                ::std::option::Option<::serde_json::Value>,
                ::std::string::String,
            >,
            source_type: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            vuln_count: ::std::result::Result<
                ::std::option::Option<i32>,
                ::std::string::String,
            >,
            vuln_critical_count: ::std::result::Result<
                ::std::option::Option<i32>,
                ::std::string::String,
            >,
            vuln_mitigated_count: ::std::result::Result<
                ::std::option::Option<i32>,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for SerializedSecurityInfo {
            fn default() -> Self {
                Self {
                    available: Err("no value supplied for available".to_string()),
                    chain_supported: Ok(Default::default()),
                    is_open_source: Ok(Default::default()),
                    is_proxy: Ok(Default::default()),
                    is_renounced: Ok(Default::default()),
                    is_safe: Ok(Default::default()),
                    last_refreshed_at: Ok(Default::default()),
                    launchpad_name: Ok(Default::default()),
                    owner_address: Ok(Default::default()),
                    raw: Ok(Default::default()),
                    source_type: Ok(Default::default()),
                    vuln_count: Ok(Default::default()),
                    vuln_critical_count: Ok(Default::default()),
                    vuln_mitigated_count: Ok(Default::default()),
                }
            }
        }
        impl SerializedSecurityInfo {
            pub fn available<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<bool>,
                T::Error: ::std::fmt::Display,
            {
                self.available = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for available: {}", e)
                    });
                self
            }
            pub fn chain_supported<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<bool>>,
                T::Error: ::std::fmt::Display,
            {
                self.chain_supported = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for chain_supported: {}", e
                        )
                    });
                self
            }
            pub fn is_open_source<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<bool>>,
                T::Error: ::std::fmt::Display,
            {
                self.is_open_source = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for is_open_source: {}", e
                        )
                    });
                self
            }
            pub fn is_proxy<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<bool>>,
                T::Error: ::std::fmt::Display,
            {
                self.is_proxy = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for is_proxy: {}", e)
                    });
                self
            }
            pub fn is_renounced<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<bool>>,
                T::Error: ::std::fmt::Display,
            {
                self.is_renounced = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for is_renounced: {}", e
                        )
                    });
                self
            }
            pub fn is_safe<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<bool>>,
                T::Error: ::std::fmt::Display,
            {
                self.is_safe = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for is_safe: {}", e)
                    });
                self
            }
            pub fn last_refreshed_at<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.last_refreshed_at = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for last_refreshed_at: {}",
                            e
                        )
                    });
                self
            }
            pub fn launchpad_name<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.launchpad_name = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for launchpad_name: {}", e
                        )
                    });
                self
            }
            pub fn owner_address<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.owner_address = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for owner_address: {}", e
                        )
                    });
                self
            }
            pub fn raw<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::serde_json::Value>>,
                T::Error: ::std::fmt::Display,
            {
                self.raw = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for raw: {}", e)
                    });
                self
            }
            pub fn source_type<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.source_type = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for source_type: {}", e)
                    });
                self
            }
            pub fn vuln_count<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<i32>>,
                T::Error: ::std::fmt::Display,
            {
                self.vuln_count = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for vuln_count: {}", e)
                    });
                self
            }
            pub fn vuln_critical_count<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<i32>>,
                T::Error: ::std::fmt::Display,
            {
                self.vuln_critical_count = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for vuln_critical_count: {}",
                            e
                        )
                    });
                self
            }
            pub fn vuln_mitigated_count<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<i32>>,
                T::Error: ::std::fmt::Display,
            {
                self.vuln_mitigated_count = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for vuln_mitigated_count: {}",
                            e
                        )
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<SerializedSecurityInfo>
        for super::SerializedSecurityInfo {
            type Error = super::error::ConversionError;
            fn try_from(
                value: SerializedSecurityInfo,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    available: value.available?,
                    chain_supported: value.chain_supported?,
                    is_open_source: value.is_open_source?,
                    is_proxy: value.is_proxy?,
                    is_renounced: value.is_renounced?,
                    is_safe: value.is_safe?,
                    last_refreshed_at: value.last_refreshed_at?,
                    launchpad_name: value.launchpad_name?,
                    owner_address: value.owner_address?,
                    raw: value.raw?,
                    source_type: value.source_type?,
                    vuln_count: value.vuln_count?,
                    vuln_critical_count: value.vuln_critical_count?,
                    vuln_mitigated_count: value.vuln_mitigated_count?,
                })
            }
        }
        impl ::std::convert::From<super::SerializedSecurityInfo>
        for SerializedSecurityInfo {
            fn from(value: super::SerializedSecurityInfo) -> Self {
                Self {
                    available: Ok(value.available),
                    chain_supported: Ok(value.chain_supported),
                    is_open_source: Ok(value.is_open_source),
                    is_proxy: Ok(value.is_proxy),
                    is_renounced: Ok(value.is_renounced),
                    is_safe: Ok(value.is_safe),
                    last_refreshed_at: Ok(value.last_refreshed_at),
                    launchpad_name: Ok(value.launchpad_name),
                    owner_address: Ok(value.owner_address),
                    raw: Ok(value.raw),
                    source_type: Ok(value.source_type),
                    vuln_count: Ok(value.vuln_count),
                    vuln_critical_count: Ok(value.vuln_critical_count),
                    vuln_mitigated_count: Ok(value.vuln_mitigated_count),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct SimilarQuery {
            limit: ::std::result::Result<
                ::std::option::Option<i64>,
                ::std::string::String,
            >,
            type_: ::std::result::Result<
                ::std::option::Option<super::SimilarType>,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for SimilarQuery {
            fn default() -> Self {
                Self {
                    limit: Ok(Default::default()),
                    type_: Ok(Default::default()),
                }
            }
        }
        impl SimilarQuery {
            pub fn limit<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<i64>>,
                T::Error: ::std::fmt::Display,
            {
                self.limit = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for limit: {}", e)
                    });
                self
            }
            pub fn type_<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<super::SimilarType>>,
                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<SimilarQuery> for super::SimilarQuery {
            type Error = super::error::ConversionError;
            fn try_from(
                value: SimilarQuery,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    limit: value.limit?,
                    type_: value.type_?,
                })
            }
        }
        impl ::std::convert::From<super::SimilarQuery> for SimilarQuery {
            fn from(value: super::SimilarQuery) -> Self {
                Self {
                    limit: Ok(value.limit),
                    type_: Ok(value.type_),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct SuccessResponse {
            success: ::std::result::Result<bool, ::std::string::String>,
        }
        impl ::std::default::Default for SuccessResponse {
            fn default() -> Self {
                Self {
                    success: Err("no value supplied for success".to_string()),
                }
            }
        }
        impl SuccessResponse {
            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<SuccessResponse> for super::SuccessResponse {
            type Error = super::error::ConversionError;
            fn try_from(
                value: SuccessResponse,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self { success: value.success? })
            }
        }
        impl ::std::convert::From<super::SuccessResponse> for SuccessResponse {
            fn from(value: super::SuccessResponse) -> Self {
                Self { success: Ok(value.success) }
            }
        }
        #[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>,
            gas_limit: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            gas_price: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::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>,
            max_fee_per_gas: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            max_priority_fee_per_gas: ::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,
            >,
            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()),
                    gas_limit: Ok(Default::default()),
                    gas_price: Ok(Default::default()),
                    input_mint: Ok(Default::default()),
                    is_anti_mev: Ok(Default::default()),
                    max_fee_per_gas: Ok(Default::default()),
                    max_priority_fee_per_gas: 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 gas_limit<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::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
            }
            pub fn gas_price<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::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
            }
            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 max_fee_per_gas<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.max_fee_per_gas = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for max_fee_per_gas: {}", e
                        )
                    });
                self
            }
            pub fn max_priority_fee_per_gas<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.max_priority_fee_per_gas = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for max_priority_fee_per_gas: {}",
                            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?,
                    gas_limit: value.gas_limit?,
                    gas_price: value.gas_price?,
                    input_mint: value.input_mint?,
                    is_anti_mev: value.is_anti_mev?,
                    max_fee_per_gas: value.max_fee_per_gas?,
                    max_priority_fee_per_gas: value.max_priority_fee_per_gas?,
                    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),
                    gas_limit: Ok(value.gas_limit),
                    gas_price: Ok(value.gas_price),
                    input_mint: Ok(value.input_mint),
                    is_anti_mev: Ok(value.is_anti_mev),
                    max_fee_per_gas: Ok(value.max_fee_per_gas),
                    max_priority_fee_per_gas: Ok(value.max_priority_fee_per_gas),
                    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>,
            last_valid_block_height: ::std::result::Result<
                ::std::option::Option<i64>,
                ::std::string::String,
            >,
            recent_blockhash: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::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()),
                    last_valid_block_height: Ok(Default::default()),
                    recent_blockhash: Ok(Default::default()),
                    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 last_valid_block_height<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<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
            }
            pub fn recent_blockhash<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.recent_blockhash = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for recent_blockhash: {}", 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?,
                    last_valid_block_height: value.last_valid_block_height?,
                    recent_blockhash: value.recent_blockhash?,
                    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),
                    last_valid_block_height: Ok(value.last_valid_block_height),
                    recent_blockhash: Ok(value.recent_blockhash),
                    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<i32, ::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<
                ::std::option::Option<super::TokenExtra>,
                ::std::string::String,
            >,
            extra: ::std::result::Result<
                ::std::option::Option<super::TokenExtra>,
                ::std::string::String,
            >,
            image_dup: ::std::result::Result<
                ::std::option::Option<bool>,
                ::std::string::String,
            >,
            image_hash: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            image_url: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            market: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            market_data: ::std::result::Result<
                ::std::option::Option<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>,
            normalized_name: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            social_medias: ::std::result::Result<
                ::std::option::Option<super::TokenSocialMedias>,
                ::std::string::String,
            >,
            stats: ::std::result::Result<
                ::std::option::Option<super::TokenStats>,
                ::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::TokenCreator>,
                ::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_dup: Ok(Default::default()),
                    image_hash: Ok(Default::default()),
                    image_url: Ok(Default::default()),
                    market: Ok(Default::default()),
                    market_data: Ok(Default::default()),
                    metadata_address: Ok(Default::default()),
                    name: Err("no value supplied for name".to_string()),
                    normalized_name: Ok(Default::default()),
                    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<i32>,
                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<::std::option::Option<super::TokenExtra>>,
                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::TokenExtra>>,
                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_dup<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<bool>>,
                T::Error: ::std::fmt::Display,
            {
                self.image_dup = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for image_dup: {}", e)
                    });
                self
            }
            pub fn image_hash<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.image_hash = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for image_hash: {}", 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 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<
                    ::std::option::Option<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 normalized_name<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.normalized_name = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for normalized_name: {}", e
                        )
                    });
                self
            }
            pub fn social_medias<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<
                    ::std::option::Option<super::TokenSocialMedias>,
                >,
                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::TokenStats>>,
                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::TokenCreator>>,
                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_dup: value.image_dup?,
                    image_hash: value.image_hash?,
                    image_url: value.image_url?,
                    market: value.market?,
                    market_data: value.market_data?,
                    metadata_address: value.metadata_address?,
                    name: value.name?,
                    normalized_name: value.normalized_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_dup: Ok(value.image_dup),
                    image_hash: Ok(value.image_hash),
                    image_url: Ok(value.image_url),
                    market: Ok(value.market),
                    market_data: Ok(value.market_data),
                    metadata_address: Ok(value.metadata_address),
                    name: Ok(value.name),
                    normalized_name: Ok(value.normalized_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 TokenBalance {
            amount: ::std::result::Result<::std::string::String, ::std::string::String>,
            amount_in_usd: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            decimals: ::std::result::Result<
                ::std::option::Option<i32>,
                ::std::string::String,
            >,
            image_url: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            token_address: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            token_name: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            token_symbol: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for TokenBalance {
            fn default() -> Self {
                Self {
                    amount: Err("no value supplied for amount".to_string()),
                    amount_in_usd: Ok(Default::default()),
                    decimals: Ok(Default::default()),
                    image_url: Ok(Default::default()),
                    token_address: Err(
                        "no value supplied for token_address".to_string(),
                    ),
                    token_name: Ok(Default::default()),
                    token_symbol: Ok(Default::default()),
                }
            }
        }
        impl TokenBalance {
            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::option::Option<::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<::std::option::Option<i32>>,
                T::Error: ::std::fmt::Display,
            {
                self.decimals = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for decimals: {}", 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 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_name<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::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_symbol<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::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
            }
        }
        impl ::std::convert::TryFrom<TokenBalance> for super::TokenBalance {
            type Error = super::error::ConversionError;
            fn try_from(
                value: TokenBalance,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    amount: value.amount?,
                    amount_in_usd: value.amount_in_usd?,
                    decimals: value.decimals?,
                    image_url: value.image_url?,
                    token_address: value.token_address?,
                    token_name: value.token_name?,
                    token_symbol: value.token_symbol?,
                })
            }
        }
        impl ::std::convert::From<super::TokenBalance> for TokenBalance {
            fn from(value: super::TokenBalance) -> Self {
                Self {
                    amount: Ok(value.amount),
                    amount_in_usd: Ok(value.amount_in_usd),
                    decimals: Ok(value.decimals),
                    image_url: Ok(value.image_url),
                    token_address: Ok(value.token_address),
                    token_name: Ok(value.token_name),
                    token_symbol: Ok(value.token_symbol),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct TokenCandle {
            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>,
            timestamp: ::std::result::Result<i64, ::std::string::String>,
            volume: ::std::result::Result<::std::string::String, ::std::string::String>,
        }
        impl ::std::default::Default for TokenCandle {
            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()),
                    timestamp: Err("no value supplied for timestamp".to_string()),
                    volume: Err("no value supplied for volume".to_string()),
                }
            }
        }
        impl TokenCandle {
            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 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 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<TokenCandle> for super::TokenCandle {
            type Error = super::error::ConversionError;
            fn try_from(
                value: TokenCandle,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    close: value.close?,
                    high: value.high?,
                    low: value.low?,
                    open: value.open?,
                    timestamp: value.timestamp?,
                    volume: value.volume?,
                })
            }
        }
        impl ::std::convert::From<super::TokenCandle> for TokenCandle {
            fn from(value: super::TokenCandle) -> Self {
                Self {
                    close: Ok(value.close),
                    high: Ok(value.high),
                    low: Ok(value.low),
                    open: Ok(value.open),
                    timestamp: Ok(value.timestamp),
                    volume: Ok(value.volume),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct TokenCreation {
            block_hash: ::std::result::Result<
                ::std::option::Option<::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<::std::string::String, ::std::string::String>,
        }
        impl ::std::default::Default for TokenCreation {
            fn default() -> Self {
                Self {
                    block_hash: Ok(Default::default()),
                    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 TokenCreation {
            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<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<::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<TokenCreation> for super::TokenCreation {
            type Error = super::error::ConversionError;
            fn try_from(
                value: TokenCreation,
            ) -> ::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::TokenCreation> for TokenCreation {
            fn from(value: super::TokenCreation) -> 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 TokenCreator {
            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 TokenCreator {
            fn default() -> Self {
                Self {
                    address: Ok(Default::default()),
                    is_verified: Ok(Default::default()),
                    share: Ok(Default::default()),
                }
            }
        }
        impl TokenCreator {
            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<TokenCreator> for super::TokenCreator {
            type Error = super::error::ConversionError;
            fn try_from(
                value: TokenCreator,
            ) -> ::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::TokenCreator> for TokenCreator {
            fn from(value: super::TokenCreator) -> Self {
                Self {
                    address: Ok(value.address),
                    is_verified: Ok(value.is_verified),
                    share: Ok(value.share),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct TokenExtra {
            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 TokenExtra {
            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 TokenExtra {
            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<TokenExtra> for super::TokenExtra {
            type Error = super::error::ConversionError;
            fn try_from(
                value: TokenExtra,
            ) -> ::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::TokenExtra> for TokenExtra {
            fn from(value: super::TokenExtra) -> 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 {
            accu_cost: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            amount: ::std::result::Result<::std::string::String, ::std::string::String>,
            amount_in_usd: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            avg_buy_price_usd: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            avg_cost_usd: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            avg_sell_price_usd: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            buy_amount_cur: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            buy_volume_native: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            buy_volume_usd: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            end_holding_at: ::std::result::Result<
                ::std::option::Option<i64>,
                ::std::string::String,
            >,
            first_buy_time: ::std::result::Result<
                ::std::option::Option<i64>,
                ::std::string::String,
            >,
            history_bought_cost: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            history_bought_fee: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            history_sold_fee: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            history_sold_income: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            history_transfer_in_amount: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            history_transfer_in_cost: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            history_transfer_out_amount: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            history_transfer_out_income: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            is_closed: ::std::result::Result<
                ::std::option::Option<bool>,
                ::std::string::String,
            >,
            is_transfer_in: ::std::result::Result<
                ::std::option::Option<bool>,
                ::std::string::String,
            >,
            last_active_at: ::std::result::Result<
                ::std::option::Option<i64>,
                ::std::string::String,
            >,
            loss_count: ::std::result::Result<
                ::std::option::Option<i64>,
                ::std::string::String,
            >,
            maker_token_tags: ::std::result::Result<
                ::std::vec::Vec<::std::string::String>,
                ::std::string::String,
            >,
            native_balance: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            netflow_usd: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            percentage: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            position_cost_usd: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            realized_pnl_ratio: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            realized_profit: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            roi: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            sell_amount_cur: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            sell_amount_percentage: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            sell_volume_native: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            sell_volume_usd: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            start_holding_at: ::std::result::Result<
                ::std::option::Option<i64>,
                ::std::string::String,
            >,
            tags: ::std::result::Result<
                ::std::vec::Vec<::std::string::String>,
                ::std::string::String,
            >,
            total_buy_count: ::std::result::Result<
                ::std::option::Option<i64>,
                ::std::string::String,
            >,
            total_cost_usd: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            total_profit: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            total_sell_count: ::std::result::Result<
                ::std::option::Option<i64>,
                ::std::string::String,
            >,
            transfer_in_amount7d: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            transfer_in_count: ::std::result::Result<
                ::std::option::Option<i64>,
                ::std::string::String,
            >,
            transfer_out_amount7d: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            transfer_out_count: ::std::result::Result<
                ::std::option::Option<i64>,
                ::std::string::String,
            >,
            unrealized_profit: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            wallet_address: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            wallet_tag_v2: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            win_count: ::std::result::Result<
                ::std::option::Option<i64>,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for TokenHolder {
            fn default() -> Self {
                Self {
                    accu_cost: Ok(Default::default()),
                    amount: Err("no value supplied for amount".to_string()),
                    amount_in_usd: Err(
                        "no value supplied for amount_in_usd".to_string(),
                    ),
                    avg_buy_price_usd: Ok(Default::default()),
                    avg_cost_usd: Ok(Default::default()),
                    avg_sell_price_usd: Ok(Default::default()),
                    buy_amount_cur: Ok(Default::default()),
                    buy_volume_native: Ok(Default::default()),
                    buy_volume_usd: Ok(Default::default()),
                    end_holding_at: Ok(Default::default()),
                    first_buy_time: Ok(Default::default()),
                    history_bought_cost: Ok(Default::default()),
                    history_bought_fee: Ok(Default::default()),
                    history_sold_fee: Ok(Default::default()),
                    history_sold_income: Ok(Default::default()),
                    history_transfer_in_amount: Ok(Default::default()),
                    history_transfer_in_cost: Ok(Default::default()),
                    history_transfer_out_amount: Ok(Default::default()),
                    history_transfer_out_income: Ok(Default::default()),
                    is_closed: Ok(Default::default()),
                    is_transfer_in: Ok(Default::default()),
                    last_active_at: Ok(Default::default()),
                    loss_count: Ok(Default::default()),
                    maker_token_tags: Ok(Default::default()),
                    native_balance: Ok(Default::default()),
                    netflow_usd: Ok(Default::default()),
                    percentage: Err("no value supplied for percentage".to_string()),
                    position_cost_usd: Ok(Default::default()),
                    realized_pnl_ratio: Ok(Default::default()),
                    realized_profit: Ok(Default::default()),
                    roi: Ok(Default::default()),
                    sell_amount_cur: Ok(Default::default()),
                    sell_amount_percentage: Ok(Default::default()),
                    sell_volume_native: Ok(Default::default()),
                    sell_volume_usd: Ok(Default::default()),
                    start_holding_at: Ok(Default::default()),
                    tags: Ok(Default::default()),
                    total_buy_count: Ok(Default::default()),
                    total_cost_usd: Ok(Default::default()),
                    total_profit: Ok(Default::default()),
                    total_sell_count: Ok(Default::default()),
                    transfer_in_amount7d: Ok(Default::default()),
                    transfer_in_count: Ok(Default::default()),
                    transfer_out_amount7d: Ok(Default::default()),
                    transfer_out_count: Ok(Default::default()),
                    unrealized_profit: Ok(Default::default()),
                    wallet_address: Err(
                        "no value supplied for wallet_address".to_string(),
                    ),
                    wallet_tag_v2: Ok(Default::default()),
                    win_count: Ok(Default::default()),
                }
            }
        }
        impl TokenHolder {
            pub fn accu_cost<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.accu_cost = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for accu_cost: {}", 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 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 avg_buy_price_usd<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.avg_buy_price_usd = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for avg_buy_price_usd: {}",
                            e
                        )
                    });
                self
            }
            pub fn avg_cost_usd<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.avg_cost_usd = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for avg_cost_usd: {}", e
                        )
                    });
                self
            }
            pub fn avg_sell_price_usd<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.avg_sell_price_usd = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for avg_sell_price_usd: {}",
                            e
                        )
                    });
                self
            }
            pub fn buy_amount_cur<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.buy_amount_cur = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for buy_amount_cur: {}", e
                        )
                    });
                self
            }
            pub fn buy_volume_native<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.buy_volume_native = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for buy_volume_native: {}",
                            e
                        )
                    });
                self
            }
            pub fn buy_volume_usd<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.buy_volume_usd = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for buy_volume_usd: {}", e
                        )
                    });
                self
            }
            pub fn end_holding_at<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<i64>>,
                T::Error: ::std::fmt::Display,
            {
                self.end_holding_at = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for end_holding_at: {}", e
                        )
                    });
                self
            }
            pub fn first_buy_time<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<i64>>,
                T::Error: ::std::fmt::Display,
            {
                self.first_buy_time = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for first_buy_time: {}", e
                        )
                    });
                self
            }
            pub fn history_bought_cost<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.history_bought_cost = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for history_bought_cost: {}",
                            e
                        )
                    });
                self
            }
            pub fn history_bought_fee<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.history_bought_fee = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for history_bought_fee: {}",
                            e
                        )
                    });
                self
            }
            pub fn history_sold_fee<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.history_sold_fee = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for history_sold_fee: {}", e
                        )
                    });
                self
            }
            pub fn history_sold_income<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.history_sold_income = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for history_sold_income: {}",
                            e
                        )
                    });
                self
            }
            pub fn history_transfer_in_amount<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.history_transfer_in_amount = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for history_transfer_in_amount: {}",
                            e
                        )
                    });
                self
            }
            pub fn history_transfer_in_cost<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.history_transfer_in_cost = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for history_transfer_in_cost: {}",
                            e
                        )
                    });
                self
            }
            pub fn history_transfer_out_amount<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.history_transfer_out_amount = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for history_transfer_out_amount: {}",
                            e
                        )
                    });
                self
            }
            pub fn history_transfer_out_income<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.history_transfer_out_income = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for history_transfer_out_income: {}",
                            e
                        )
                    });
                self
            }
            pub fn is_closed<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<bool>>,
                T::Error: ::std::fmt::Display,
            {
                self.is_closed = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for is_closed: {}", e)
                    });
                self
            }
            pub fn is_transfer_in<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<bool>>,
                T::Error: ::std::fmt::Display,
            {
                self.is_transfer_in = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for is_transfer_in: {}", e
                        )
                    });
                self
            }
            pub fn last_active_at<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<i64>>,
                T::Error: ::std::fmt::Display,
            {
                self.last_active_at = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for last_active_at: {}", e
                        )
                    });
                self
            }
            pub fn loss_count<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<i64>>,
                T::Error: ::std::fmt::Display,
            {
                self.loss_count = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for loss_count: {}", e)
                    });
                self
            }
            pub fn maker_token_tags<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::vec::Vec<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.maker_token_tags = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for maker_token_tags: {}", e
                        )
                    });
                self
            }
            pub fn native_balance<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.native_balance = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for native_balance: {}", e
                        )
                    });
                self
            }
            pub fn netflow_usd<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.netflow_usd = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for netflow_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 position_cost_usd<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.position_cost_usd = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for position_cost_usd: {}",
                            e
                        )
                    });
                self
            }
            pub fn realized_pnl_ratio<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.realized_pnl_ratio = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for realized_pnl_ratio: {}",
                            e
                        )
                    });
                self
            }
            pub fn realized_profit<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.realized_profit = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for realized_profit: {}", e
                        )
                    });
                self
            }
            pub fn roi<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.roi = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for roi: {}", e)
                    });
                self
            }
            pub fn sell_amount_cur<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.sell_amount_cur = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for sell_amount_cur: {}", e
                        )
                    });
                self
            }
            pub fn sell_amount_percentage<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.sell_amount_percentage = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for sell_amount_percentage: {}",
                            e
                        )
                    });
                self
            }
            pub fn sell_volume_native<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.sell_volume_native = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for sell_volume_native: {}",
                            e
                        )
                    });
                self
            }
            pub fn sell_volume_usd<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.sell_volume_usd = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for sell_volume_usd: {}", e
                        )
                    });
                self
            }
            pub fn start_holding_at<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<i64>>,
                T::Error: ::std::fmt::Display,
            {
                self.start_holding_at = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for start_holding_at: {}", e
                        )
                    });
                self
            }
            pub fn tags<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::vec::Vec<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.tags = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for tags: {}", e)
                    });
                self
            }
            pub fn total_buy_count<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<i64>>,
                T::Error: ::std::fmt::Display,
            {
                self.total_buy_count = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for total_buy_count: {}", e
                        )
                    });
                self
            }
            pub fn total_cost_usd<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.total_cost_usd = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for total_cost_usd: {}", e
                        )
                    });
                self
            }
            pub fn total_profit<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.total_profit = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for total_profit: {}", e
                        )
                    });
                self
            }
            pub fn total_sell_count<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<i64>>,
                T::Error: ::std::fmt::Display,
            {
                self.total_sell_count = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for total_sell_count: {}", e
                        )
                    });
                self
            }
            pub fn transfer_in_amount7d<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.transfer_in_amount7d = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for transfer_in_amount7d: {}",
                            e
                        )
                    });
                self
            }
            pub fn transfer_in_count<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<i64>>,
                T::Error: ::std::fmt::Display,
            {
                self.transfer_in_count = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for transfer_in_count: {}",
                            e
                        )
                    });
                self
            }
            pub fn transfer_out_amount7d<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.transfer_out_amount7d = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for transfer_out_amount7d: {}",
                            e
                        )
                    });
                self
            }
            pub fn transfer_out_count<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<i64>>,
                T::Error: ::std::fmt::Display,
            {
                self.transfer_out_count = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for transfer_out_count: {}",
                            e
                        )
                    });
                self
            }
            pub fn unrealized_profit<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.unrealized_profit = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for unrealized_profit: {}",
                            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 wallet_tag_v2<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.wallet_tag_v2 = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for wallet_tag_v2: {}", e
                        )
                    });
                self
            }
            pub fn win_count<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<i64>>,
                T::Error: ::std::fmt::Display,
            {
                self.win_count = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for win_count: {}", 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 {
                    accu_cost: value.accu_cost?,
                    amount: value.amount?,
                    amount_in_usd: value.amount_in_usd?,
                    avg_buy_price_usd: value.avg_buy_price_usd?,
                    avg_cost_usd: value.avg_cost_usd?,
                    avg_sell_price_usd: value.avg_sell_price_usd?,
                    buy_amount_cur: value.buy_amount_cur?,
                    buy_volume_native: value.buy_volume_native?,
                    buy_volume_usd: value.buy_volume_usd?,
                    end_holding_at: value.end_holding_at?,
                    first_buy_time: value.first_buy_time?,
                    history_bought_cost: value.history_bought_cost?,
                    history_bought_fee: value.history_bought_fee?,
                    history_sold_fee: value.history_sold_fee?,
                    history_sold_income: value.history_sold_income?,
                    history_transfer_in_amount: value.history_transfer_in_amount?,
                    history_transfer_in_cost: value.history_transfer_in_cost?,
                    history_transfer_out_amount: value.history_transfer_out_amount?,
                    history_transfer_out_income: value.history_transfer_out_income?,
                    is_closed: value.is_closed?,
                    is_transfer_in: value.is_transfer_in?,
                    last_active_at: value.last_active_at?,
                    loss_count: value.loss_count?,
                    maker_token_tags: value.maker_token_tags?,
                    native_balance: value.native_balance?,
                    netflow_usd: value.netflow_usd?,
                    percentage: value.percentage?,
                    position_cost_usd: value.position_cost_usd?,
                    realized_pnl_ratio: value.realized_pnl_ratio?,
                    realized_profit: value.realized_profit?,
                    roi: value.roi?,
                    sell_amount_cur: value.sell_amount_cur?,
                    sell_amount_percentage: value.sell_amount_percentage?,
                    sell_volume_native: value.sell_volume_native?,
                    sell_volume_usd: value.sell_volume_usd?,
                    start_holding_at: value.start_holding_at?,
                    tags: value.tags?,
                    total_buy_count: value.total_buy_count?,
                    total_cost_usd: value.total_cost_usd?,
                    total_profit: value.total_profit?,
                    total_sell_count: value.total_sell_count?,
                    transfer_in_amount7d: value.transfer_in_amount7d?,
                    transfer_in_count: value.transfer_in_count?,
                    transfer_out_amount7d: value.transfer_out_amount7d?,
                    transfer_out_count: value.transfer_out_count?,
                    unrealized_profit: value.unrealized_profit?,
                    wallet_address: value.wallet_address?,
                    wallet_tag_v2: value.wallet_tag_v2?,
                    win_count: value.win_count?,
                })
            }
        }
        impl ::std::convert::From<super::TokenHolder> for TokenHolder {
            fn from(value: super::TokenHolder) -> Self {
                Self {
                    accu_cost: Ok(value.accu_cost),
                    amount: Ok(value.amount),
                    amount_in_usd: Ok(value.amount_in_usd),
                    avg_buy_price_usd: Ok(value.avg_buy_price_usd),
                    avg_cost_usd: Ok(value.avg_cost_usd),
                    avg_sell_price_usd: Ok(value.avg_sell_price_usd),
                    buy_amount_cur: Ok(value.buy_amount_cur),
                    buy_volume_native: Ok(value.buy_volume_native),
                    buy_volume_usd: Ok(value.buy_volume_usd),
                    end_holding_at: Ok(value.end_holding_at),
                    first_buy_time: Ok(value.first_buy_time),
                    history_bought_cost: Ok(value.history_bought_cost),
                    history_bought_fee: Ok(value.history_bought_fee),
                    history_sold_fee: Ok(value.history_sold_fee),
                    history_sold_income: Ok(value.history_sold_income),
                    history_transfer_in_amount: Ok(value.history_transfer_in_amount),
                    history_transfer_in_cost: Ok(value.history_transfer_in_cost),
                    history_transfer_out_amount: Ok(value.history_transfer_out_amount),
                    history_transfer_out_income: Ok(value.history_transfer_out_income),
                    is_closed: Ok(value.is_closed),
                    is_transfer_in: Ok(value.is_transfer_in),
                    last_active_at: Ok(value.last_active_at),
                    loss_count: Ok(value.loss_count),
                    maker_token_tags: Ok(value.maker_token_tags),
                    native_balance: Ok(value.native_balance),
                    netflow_usd: Ok(value.netflow_usd),
                    percentage: Ok(value.percentage),
                    position_cost_usd: Ok(value.position_cost_usd),
                    realized_pnl_ratio: Ok(value.realized_pnl_ratio),
                    realized_profit: Ok(value.realized_profit),
                    roi: Ok(value.roi),
                    sell_amount_cur: Ok(value.sell_amount_cur),
                    sell_amount_percentage: Ok(value.sell_amount_percentage),
                    sell_volume_native: Ok(value.sell_volume_native),
                    sell_volume_usd: Ok(value.sell_volume_usd),
                    start_holding_at: Ok(value.start_holding_at),
                    tags: Ok(value.tags),
                    total_buy_count: Ok(value.total_buy_count),
                    total_cost_usd: Ok(value.total_cost_usd),
                    total_profit: Ok(value.total_profit),
                    total_sell_count: Ok(value.total_sell_count),
                    transfer_in_amount7d: Ok(value.transfer_in_amount7d),
                    transfer_in_count: Ok(value.transfer_in_count),
                    transfer_out_amount7d: Ok(value.transfer_out_amount7d),
                    transfer_out_count: Ok(value.transfer_out_count),
                    unrealized_profit: Ok(value.unrealized_profit),
                    wallet_address: Ok(value.wallet_address),
                    wallet_tag_v2: Ok(value.wallet_tag_v2),
                    win_count: Ok(value.win_count),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct TokenHolderTrendPoint {
            bluechip_amount_ratio: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            bundle_amount_ratio: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            creators_amount_ratio: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            dev_amount_ratio: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            fresh_amount_ratio: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            holders: ::std::result::Result<::std::string::String, ::std::string::String>,
            insider_amount_ratio: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            kol_amount_ratio: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            phishing_amount_ratio: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            pro_amount_ratio: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            rat_amount_ratio: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            sandwich_amount_ratio: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            smart_amount_ratio: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            sniper_amount_ratio: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            timestamp: ::std::result::Result<i64, ::std::string::String>,
            top100_holders_ratio: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            top10_holders_ratio: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            top50_holders_ratio: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for TokenHolderTrendPoint {
            fn default() -> Self {
                Self {
                    bluechip_amount_ratio: Err(
                        "no value supplied for bluechip_amount_ratio".to_string(),
                    ),
                    bundle_amount_ratio: Err(
                        "no value supplied for bundle_amount_ratio".to_string(),
                    ),
                    creators_amount_ratio: Err(
                        "no value supplied for creators_amount_ratio".to_string(),
                    ),
                    dev_amount_ratio: Err(
                        "no value supplied for dev_amount_ratio".to_string(),
                    ),
                    fresh_amount_ratio: Err(
                        "no value supplied for fresh_amount_ratio".to_string(),
                    ),
                    holders: Err("no value supplied for holders".to_string()),
                    insider_amount_ratio: Err(
                        "no value supplied for insider_amount_ratio".to_string(),
                    ),
                    kol_amount_ratio: Err(
                        "no value supplied for kol_amount_ratio".to_string(),
                    ),
                    phishing_amount_ratio: Err(
                        "no value supplied for phishing_amount_ratio".to_string(),
                    ),
                    pro_amount_ratio: Err(
                        "no value supplied for pro_amount_ratio".to_string(),
                    ),
                    rat_amount_ratio: Err(
                        "no value supplied for rat_amount_ratio".to_string(),
                    ),
                    sandwich_amount_ratio: Err(
                        "no value supplied for sandwich_amount_ratio".to_string(),
                    ),
                    smart_amount_ratio: Err(
                        "no value supplied for smart_amount_ratio".to_string(),
                    ),
                    sniper_amount_ratio: Err(
                        "no value supplied for sniper_amount_ratio".to_string(),
                    ),
                    timestamp: Err("no value supplied for timestamp".to_string()),
                    top100_holders_ratio: Err(
                        "no value supplied for top100_holders_ratio".to_string(),
                    ),
                    top10_holders_ratio: Err(
                        "no value supplied for top10_holders_ratio".to_string(),
                    ),
                    top50_holders_ratio: Err(
                        "no value supplied for top50_holders_ratio".to_string(),
                    ),
                }
            }
        }
        impl TokenHolderTrendPoint {
            pub fn bluechip_amount_ratio<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.bluechip_amount_ratio = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for bluechip_amount_ratio: {}",
                            e
                        )
                    });
                self
            }
            pub fn bundle_amount_ratio<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.bundle_amount_ratio = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for bundle_amount_ratio: {}",
                            e
                        )
                    });
                self
            }
            pub fn creators_amount_ratio<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.creators_amount_ratio = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for creators_amount_ratio: {}",
                            e
                        )
                    });
                self
            }
            pub fn dev_amount_ratio<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.dev_amount_ratio = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for dev_amount_ratio: {}", e
                        )
                    });
                self
            }
            pub fn fresh_amount_ratio<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.fresh_amount_ratio = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for fresh_amount_ratio: {}",
                            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_amount_ratio<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.insider_amount_ratio = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for insider_amount_ratio: {}",
                            e
                        )
                    });
                self
            }
            pub fn kol_amount_ratio<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.kol_amount_ratio = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for kol_amount_ratio: {}", e
                        )
                    });
                self
            }
            pub fn phishing_amount_ratio<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.phishing_amount_ratio = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for phishing_amount_ratio: {}",
                            e
                        )
                    });
                self
            }
            pub fn pro_amount_ratio<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.pro_amount_ratio = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for pro_amount_ratio: {}", e
                        )
                    });
                self
            }
            pub fn rat_amount_ratio<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.rat_amount_ratio = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for rat_amount_ratio: {}", e
                        )
                    });
                self
            }
            pub fn sandwich_amount_ratio<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.sandwich_amount_ratio = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for sandwich_amount_ratio: {}",
                            e
                        )
                    });
                self
            }
            pub fn smart_amount_ratio<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.smart_amount_ratio = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for smart_amount_ratio: {}",
                            e
                        )
                    });
                self
            }
            pub fn sniper_amount_ratio<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.sniper_amount_ratio = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for sniper_amount_ratio: {}",
                            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 top100_holders_ratio<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.top100_holders_ratio = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for top100_holders_ratio: {}",
                            e
                        )
                    });
                self
            }
            pub fn top10_holders_ratio<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.top10_holders_ratio = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for top10_holders_ratio: {}",
                            e
                        )
                    });
                self
            }
            pub fn top50_holders_ratio<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.top50_holders_ratio = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for top50_holders_ratio: {}",
                            e
                        )
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<TokenHolderTrendPoint>
        for super::TokenHolderTrendPoint {
            type Error = super::error::ConversionError;
            fn try_from(
                value: TokenHolderTrendPoint,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    bluechip_amount_ratio: value.bluechip_amount_ratio?,
                    bundle_amount_ratio: value.bundle_amount_ratio?,
                    creators_amount_ratio: value.creators_amount_ratio?,
                    dev_amount_ratio: value.dev_amount_ratio?,
                    fresh_amount_ratio: value.fresh_amount_ratio?,
                    holders: value.holders?,
                    insider_amount_ratio: value.insider_amount_ratio?,
                    kol_amount_ratio: value.kol_amount_ratio?,
                    phishing_amount_ratio: value.phishing_amount_ratio?,
                    pro_amount_ratio: value.pro_amount_ratio?,
                    rat_amount_ratio: value.rat_amount_ratio?,
                    sandwich_amount_ratio: value.sandwich_amount_ratio?,
                    smart_amount_ratio: value.smart_amount_ratio?,
                    sniper_amount_ratio: value.sniper_amount_ratio?,
                    timestamp: value.timestamp?,
                    top100_holders_ratio: value.top100_holders_ratio?,
                    top10_holders_ratio: value.top10_holders_ratio?,
                    top50_holders_ratio: value.top50_holders_ratio?,
                })
            }
        }
        impl ::std::convert::From<super::TokenHolderTrendPoint>
        for TokenHolderTrendPoint {
            fn from(value: super::TokenHolderTrendPoint) -> Self {
                Self {
                    bluechip_amount_ratio: Ok(value.bluechip_amount_ratio),
                    bundle_amount_ratio: Ok(value.bundle_amount_ratio),
                    creators_amount_ratio: Ok(value.creators_amount_ratio),
                    dev_amount_ratio: Ok(value.dev_amount_ratio),
                    fresh_amount_ratio: Ok(value.fresh_amount_ratio),
                    holders: Ok(value.holders),
                    insider_amount_ratio: Ok(value.insider_amount_ratio),
                    kol_amount_ratio: Ok(value.kol_amount_ratio),
                    phishing_amount_ratio: Ok(value.phishing_amount_ratio),
                    pro_amount_ratio: Ok(value.pro_amount_ratio),
                    rat_amount_ratio: Ok(value.rat_amount_ratio),
                    sandwich_amount_ratio: Ok(value.sandwich_amount_ratio),
                    smart_amount_ratio: Ok(value.smart_amount_ratio),
                    sniper_amount_ratio: Ok(value.sniper_amount_ratio),
                    timestamp: Ok(value.timestamp),
                    top100_holders_ratio: Ok(value.top100_holders_ratio),
                    top10_holders_ratio: Ok(value.top10_holders_ratio),
                    top50_holders_ratio: Ok(value.top50_holders_ratio),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct TokenLiquiditySnapshot {
            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 TokenLiquiditySnapshot {
            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 TokenLiquiditySnapshot {
            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<TokenLiquiditySnapshot>
        for super::TokenLiquiditySnapshot {
            type Error = super::error::ConversionError;
            fn try_from(
                value: TokenLiquiditySnapshot,
            ) -> ::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::TokenLiquiditySnapshot>
        for TokenLiquiditySnapshot {
            fn from(value: super::TokenLiquiditySnapshot) -> 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 TokenMarketData {
            ath_market_cap_in_usd: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            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,
            >,
            circulating_supply: ::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,
            >,
            creators_holdings_ratio: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            creators_total_holders: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            creators_total_holdings: ::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,
            >,
            fdv_in_sol: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            fdv_in_usd: ::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::option::Option<::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::option::Option<::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,
            >,
            phishing_holdings_ratio: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            phishing_total_holders: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            phishing_total_holdings: ::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::option::Option<::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,
            >,
            rat_holdings_ratio: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            rat_total_holders: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            rat_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,
            >,
            smart_holdings_ratio: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            smart_total_holders: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            smart_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::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            total_tvl_in_sol: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            total_tvl_in_usd: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for TokenMarketData {
            fn default() -> Self {
                Self {
                    ath_market_cap_in_usd: Ok(Default::default()),
                    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()),
                    circulating_supply: Ok(Default::default()),
                    completion_ratio: Ok(Default::default()),
                    creators_holdings_ratio: Ok(Default::default()),
                    creators_total_holders: Ok(Default::default()),
                    creators_total_holdings: Ok(Default::default()),
                    dev_holdings_ratio: Ok(Default::default()),
                    dev_total_holders: Ok(Default::default()),
                    dev_total_holdings: Ok(Default::default()),
                    fdv_in_sol: Ok(Default::default()),
                    fdv_in_usd: Ok(Default::default()),
                    fresh_holdings_ratio: Ok(Default::default()),
                    fresh_total_holders: Ok(Default::default()),
                    fresh_total_holdings: Ok(Default::default()),
                    holders: Ok(Default::default()),
                    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: Ok(Default::default()),
                    max_pool_tvl_in_sol: Ok(Default::default()),
                    max_pool_tvl_in_usd: Ok(Default::default()),
                    phishing_holdings_ratio: Ok(Default::default()),
                    phishing_total_holders: Ok(Default::default()),
                    phishing_total_holdings: Ok(Default::default()),
                    price_in_sol: Ok(Default::default()),
                    price_in_usd: Ok(Default::default()),
                    pro_holdings_ratio: Ok(Default::default()),
                    pro_total_holders: Ok(Default::default()),
                    pro_total_holdings: Ok(Default::default()),
                    rat_holdings_ratio: Ok(Default::default()),
                    rat_total_holders: Ok(Default::default()),
                    rat_total_holdings: Ok(Default::default()),
                    sandwish_holdings_ratio: Ok(Default::default()),
                    sandwish_total_holders: Ok(Default::default()),
                    sandwish_total_holdings: Ok(Default::default()),
                    smart_holdings_ratio: Ok(Default::default()),
                    smart_total_holders: Ok(Default::default()),
                    smart_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: Ok(Default::default()),
                    total_tvl_in_sol: Ok(Default::default()),
                    total_tvl_in_usd: Ok(Default::default()),
                }
            }
        }
        impl TokenMarketData {
            pub fn ath_market_cap_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.ath_market_cap_in_usd = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for ath_market_cap_in_usd: {}",
                            e
                        )
                    });
                self
            }
            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 circulating_supply<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.circulating_supply = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for circulating_supply: {}",
                            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 creators_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.creators_holdings_ratio = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for creators_holdings_ratio: {}",
                            e
                        )
                    });
                self
            }
            pub fn creators_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.creators_total_holders = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for creators_total_holders: {}",
                            e
                        )
                    });
                self
            }
            pub fn creators_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.creators_total_holdings = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for creators_total_holdings: {}",
                            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 fdv_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.fdv_in_sol = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for fdv_in_sol: {}", e)
                    });
                self
            }
            pub fn fdv_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.fdv_in_usd = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for fdv_in_usd: {}", 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::option::Option<::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::option::Option<::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 phishing_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.phishing_holdings_ratio = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for phishing_holdings_ratio: {}",
                            e
                        )
                    });
                self
            }
            pub fn phishing_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.phishing_total_holders = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for phishing_total_holders: {}",
                            e
                        )
                    });
                self
            }
            pub fn phishing_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.phishing_total_holdings = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for phishing_total_holdings: {}",
                            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::option::Option<::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 rat_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.rat_holdings_ratio = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for rat_holdings_ratio: {}",
                            e
                        )
                    });
                self
            }
            pub fn rat_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.rat_total_holders = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for rat_total_holders: {}",
                            e
                        )
                    });
                self
            }
            pub fn rat_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.rat_total_holdings = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for rat_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 smart_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.smart_holdings_ratio = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for smart_holdings_ratio: {}",
                            e
                        )
                    });
                self
            }
            pub fn smart_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.smart_total_holders = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for smart_total_holders: {}",
                            e
                        )
                    });
                self
            }
            pub fn smart_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.smart_total_holdings = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for smart_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::option::Option<::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::option::Option<::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::option::Option<::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 {
                    ath_market_cap_in_usd: value.ath_market_cap_in_usd?,
                    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?,
                    circulating_supply: value.circulating_supply?,
                    completion_ratio: value.completion_ratio?,
                    creators_holdings_ratio: value.creators_holdings_ratio?,
                    creators_total_holders: value.creators_total_holders?,
                    creators_total_holdings: value.creators_total_holdings?,
                    dev_holdings_ratio: value.dev_holdings_ratio?,
                    dev_total_holders: value.dev_total_holders?,
                    dev_total_holdings: value.dev_total_holdings?,
                    fdv_in_sol: value.fdv_in_sol?,
                    fdv_in_usd: value.fdv_in_usd?,
                    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?,
                    phishing_holdings_ratio: value.phishing_holdings_ratio?,
                    phishing_total_holders: value.phishing_total_holders?,
                    phishing_total_holdings: value.phishing_total_holdings?,
                    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?,
                    rat_holdings_ratio: value.rat_holdings_ratio?,
                    rat_total_holders: value.rat_total_holders?,
                    rat_total_holdings: value.rat_total_holdings?,
                    sandwish_holdings_ratio: value.sandwish_holdings_ratio?,
                    sandwish_total_holders: value.sandwish_total_holders?,
                    sandwish_total_holdings: value.sandwish_total_holdings?,
                    smart_holdings_ratio: value.smart_holdings_ratio?,
                    smart_total_holders: value.smart_total_holders?,
                    smart_total_holdings: value.smart_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 {
                    ath_market_cap_in_usd: Ok(value.ath_market_cap_in_usd),
                    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),
                    circulating_supply: Ok(value.circulating_supply),
                    completion_ratio: Ok(value.completion_ratio),
                    creators_holdings_ratio: Ok(value.creators_holdings_ratio),
                    creators_total_holders: Ok(value.creators_total_holders),
                    creators_total_holdings: Ok(value.creators_total_holdings),
                    dev_holdings_ratio: Ok(value.dev_holdings_ratio),
                    dev_total_holders: Ok(value.dev_total_holders),
                    dev_total_holdings: Ok(value.dev_total_holdings),
                    fdv_in_sol: Ok(value.fdv_in_sol),
                    fdv_in_usd: Ok(value.fdv_in_usd),
                    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),
                    phishing_holdings_ratio: Ok(value.phishing_holdings_ratio),
                    phishing_total_holders: Ok(value.phishing_total_holders),
                    phishing_total_holdings: Ok(value.phishing_total_holdings),
                    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),
                    rat_holdings_ratio: Ok(value.rat_holdings_ratio),
                    rat_total_holders: Ok(value.rat_total_holders),
                    rat_total_holdings: Ok(value.rat_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),
                    smart_holdings_ratio: Ok(value.smart_holdings_ratio),
                    smart_total_holders: Ok(value.smart_total_holders),
                    smart_total_holdings: Ok(value.smart_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<
                ::std::string::String,
                ::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::TokenExtra>,
                ::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::TokenSocialMedias>,
                ::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::TokenCreator>,
                ::std::string::String,
            >,
            updated_at: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::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()),
                    updated_at: 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<::std::string::String>,
                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::TokenExtra>>,
                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::TokenSocialMedias>,
                >,
                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::TokenCreator>>,
                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 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 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?,
                    updated_at: value.updated_at?,
                    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),
                    updated_at: Ok(value.updated_at),
                    uri: Ok(value.uri),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct TokenMintBurn {
            amount: ::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>,
            mint_burn_type: ::std::result::Result<
                super::MintBurnType,
                ::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,
            >,
        }
        impl ::std::default::Default for TokenMintBurn {
            fn default() -> Self {
                Self {
                    amount: Err("no value supplied for amount".to_string()),
                    block_height: Err("no value supplied for block_height".to_string()),
                    block_timestamp: Err(
                        "no value supplied for block_timestamp".to_string(),
                    ),
                    mint_burn_type: Err(
                        "no value supplied for mint_burn_type".to_string(),
                    ),
                    token_address: Err(
                        "no value supplied for token_address".to_string(),
                    ),
                    transaction_signature: Err(
                        "no value supplied for transaction_signature".to_string(),
                    ),
                }
            }
        }
        impl TokenMintBurn {
            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_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 mint_burn_type<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<super::MintBurnType>,
                T::Error: ::std::fmt::Display,
            {
                self.mint_burn_type = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for mint_burn_type: {}", 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
            }
        }
        impl ::std::convert::TryFrom<TokenMintBurn> for super::TokenMintBurn {
            type Error = super::error::ConversionError;
            fn try_from(
                value: TokenMintBurn,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    amount: value.amount?,
                    block_height: value.block_height?,
                    block_timestamp: value.block_timestamp?,
                    mint_burn_type: value.mint_burn_type?,
                    token_address: value.token_address?,
                    transaction_signature: value.transaction_signature?,
                })
            }
        }
        impl ::std::convert::From<super::TokenMintBurn> for TokenMintBurn {
            fn from(value: super::TokenMintBurn) -> Self {
                Self {
                    amount: Ok(value.amount),
                    block_height: Ok(value.block_height),
                    block_timestamp: Ok(value.block_timestamp),
                    mint_burn_type: Ok(value.mint_burn_type),
                    token_address: Ok(value.token_address),
                    transaction_signature: Ok(value.transaction_signature),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct TokenPage {
            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<
                ::std::option::Option<bool>,
                ::std::string::String,
            >,
            has_prev: ::std::result::Result<
                ::std::option::Option<bool>,
                ::std::string::String,
            >,
            start_cursor: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for TokenPage {
            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()),
                }
            }
        }
        impl TokenPage {
            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<::std::option::Option<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<::std::option::Option<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<TokenPage> for super::TokenPage {
            type Error = super::error::ConversionError;
            fn try_from(
                value: TokenPage,
            ) -> ::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::TokenPage> for TokenPage {
            fn from(value: super::TokenPage) -> 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 TokenPrice {
            address: ::std::result::Result<::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,
            >,
            timestamp: ::std::result::Result<i64, ::std::string::String>,
        }
        impl ::std::default::Default for TokenPrice {
            fn default() -> Self {
                Self {
                    address: Err("no value supplied for address".to_string()),
                    price_in_sol: Ok(Default::default()),
                    price_in_usd: Err("no value supplied for price_in_usd".to_string()),
                    timestamp: Err("no value supplied for timestamp".to_string()),
                }
            }
        }
        impl TokenPrice {
            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 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 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
            }
        }
        impl ::std::convert::TryFrom<TokenPrice> for super::TokenPrice {
            type Error = super::error::ConversionError;
            fn try_from(
                value: TokenPrice,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    address: value.address?,
                    price_in_sol: value.price_in_sol?,
                    price_in_usd: value.price_in_usd?,
                    timestamp: value.timestamp?,
                })
            }
        }
        impl ::std::convert::From<super::TokenPrice> for TokenPrice {
            fn from(value: super::TokenPrice) -> Self {
                Self {
                    address: Ok(value.address),
                    price_in_sol: Ok(value.price_in_sol),
                    price_in_usd: Ok(value.price_in_usd),
                    timestamp: Ok(value.timestamp),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct TokenSecurityResponse {
            address: ::std::result::Result<::std::string::String, ::std::string::String>,
            chain: ::std::result::Result<::std::string::String, ::std::string::String>,
            goplus: ::std::result::Result<
                ::std::option::Option<super::GoPlusSecurityInfo>,
                ::std::string::String,
            >,
            honeypot: ::std::result::Result<
                ::std::option::Option<super::HoneypotIsSecurityInfo>,
                ::std::string::String,
            >,
            serialized: ::std::result::Result<
                ::std::option::Option<super::SerializedSecurityInfo>,
                ::std::string::String,
            >,
            sources_available: ::std::result::Result<
                ::std::vec::Vec<::std::string::String>,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for TokenSecurityResponse {
            fn default() -> Self {
                Self {
                    address: Err("no value supplied for address".to_string()),
                    chain: Err("no value supplied for chain".to_string()),
                    goplus: Ok(Default::default()),
                    honeypot: Ok(Default::default()),
                    serialized: Ok(Default::default()),
                    sources_available: Ok(Default::default()),
                }
            }
        }
        impl TokenSecurityResponse {
            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 goplus<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<
                    ::std::option::Option<super::GoPlusSecurityInfo>,
                >,
                T::Error: ::std::fmt::Display,
            {
                self.goplus = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for goplus: {}", e)
                    });
                self
            }
            pub fn honeypot<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<
                    ::std::option::Option<super::HoneypotIsSecurityInfo>,
                >,
                T::Error: ::std::fmt::Display,
            {
                self.honeypot = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for honeypot: {}", e)
                    });
                self
            }
            pub fn serialized<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<
                    ::std::option::Option<super::SerializedSecurityInfo>,
                >,
                T::Error: ::std::fmt::Display,
            {
                self.serialized = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for serialized: {}", e)
                    });
                self
            }
            pub fn sources_available<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::vec::Vec<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.sources_available = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for sources_available: {}",
                            e
                        )
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<TokenSecurityResponse>
        for super::TokenSecurityResponse {
            type Error = super::error::ConversionError;
            fn try_from(
                value: TokenSecurityResponse,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    address: value.address?,
                    chain: value.chain?,
                    goplus: value.goplus?,
                    honeypot: value.honeypot?,
                    serialized: value.serialized?,
                    sources_available: value.sources_available?,
                })
            }
        }
        impl ::std::convert::From<super::TokenSecurityResponse>
        for TokenSecurityResponse {
            fn from(value: super::TokenSecurityResponse) -> Self {
                Self {
                    address: Ok(value.address),
                    chain: Ok(value.chain),
                    goplus: Ok(value.goplus),
                    honeypot: Ok(value.honeypot),
                    serialized: Ok(value.serialized),
                    sources_available: Ok(value.sources_available),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct TokenSocialMedias {
            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 TokenSocialMedias {
            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 TokenSocialMedias {
            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<TokenSocialMedias> for super::TokenSocialMedias {
            type Error = super::error::ConversionError;
            fn try_from(
                value: TokenSocialMedias,
            ) -> ::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::TokenSocialMedias> for TokenSocialMedias {
            fn from(value: super::TokenSocialMedias) -> 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 TokenStats {
            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 TokenStats {
            fn default() -> Self {
                Self {
                    address: Err("no value supplied for address".to_string()),
                    periods: Err("no value supplied for periods".to_string()),
                }
            }
        }
        impl TokenStats {
            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<TokenStats> for super::TokenStats {
            type Error = super::error::ConversionError;
            fn try_from(
                value: TokenStats,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    address: value.address?,
                    periods: value.periods?,
                })
            }
        }
        impl ::std::convert::From<super::TokenStats> for TokenStats {
            fn from(value: super::TokenStats) -> Self {
                Self {
                    address: Ok(value.address),
                    periods: Ok(value.periods),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct TokenTradeStatPeriod {
            average_price_in_native: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            average_price_in_usd: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            buy_sell_ratio: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            buy_volume: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            buy_volume_in_native: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            buy_volume_in_usd: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            buyers: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            buys: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            close_in_native: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            close_in_usd: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            current_liquidity_in_usd: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            dapp_program_count: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            high_in_native: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            high_in_usd: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            liquidity_change_ratio: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            low_in_native: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            low_in_usd: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            open_in_native: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            open_in_usd: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            pool_count: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            prev_buy_volume: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            prev_buy_volume_in_native: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            prev_buy_volume_in_usd: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            prev_buyers: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            prev_buys: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            prev_close_in_native: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            prev_close_in_usd: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            prev_dapp_program_count: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            prev_high_in_native: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            prev_high_in_usd: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            prev_liquidity_in_usd: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            prev_low_in_native: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            prev_low_in_usd: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            prev_open_in_native: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            prev_open_in_usd: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            prev_pool_count: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            prev_sell_volume: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            prev_sell_volume_in_native: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            prev_sell_volume_in_usd: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            prev_sellers: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            prev_sells: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            prev_trades: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            price_change_ratio_in_usd: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            sell_volume: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            sell_volume_in_native: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            sell_volume_in_usd: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            sellers: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            sells: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            total_volume_in_native: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            total_volume_in_usd: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            traders: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            trades: ::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,
            >,
            volume_change_ratio: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for TokenTradeStatPeriod {
            fn default() -> Self {
                Self {
                    average_price_in_native: Ok(Default::default()),
                    average_price_in_usd: Ok(Default::default()),
                    buy_sell_ratio: Ok(Default::default()),
                    buy_volume: Ok(Default::default()),
                    buy_volume_in_native: Ok(Default::default()),
                    buy_volume_in_usd: Ok(Default::default()),
                    buyers: Ok(Default::default()),
                    buys: Ok(Default::default()),
                    close_in_native: Ok(Default::default()),
                    close_in_usd: Ok(Default::default()),
                    current_liquidity_in_usd: Ok(Default::default()),
                    dapp_program_count: Ok(Default::default()),
                    high_in_native: Ok(Default::default()),
                    high_in_usd: Ok(Default::default()),
                    liquidity_change_ratio: Ok(Default::default()),
                    low_in_native: Ok(Default::default()),
                    low_in_usd: Ok(Default::default()),
                    open_in_native: Ok(Default::default()),
                    open_in_usd: Ok(Default::default()),
                    pool_count: Ok(Default::default()),
                    prev_buy_volume: Ok(Default::default()),
                    prev_buy_volume_in_native: Ok(Default::default()),
                    prev_buy_volume_in_usd: Ok(Default::default()),
                    prev_buyers: Ok(Default::default()),
                    prev_buys: Ok(Default::default()),
                    prev_close_in_native: Ok(Default::default()),
                    prev_close_in_usd: Ok(Default::default()),
                    prev_dapp_program_count: Ok(Default::default()),
                    prev_high_in_native: Ok(Default::default()),
                    prev_high_in_usd: Ok(Default::default()),
                    prev_liquidity_in_usd: Ok(Default::default()),
                    prev_low_in_native: Ok(Default::default()),
                    prev_low_in_usd: Ok(Default::default()),
                    prev_open_in_native: Ok(Default::default()),
                    prev_open_in_usd: Ok(Default::default()),
                    prev_pool_count: Ok(Default::default()),
                    prev_sell_volume: Ok(Default::default()),
                    prev_sell_volume_in_native: Ok(Default::default()),
                    prev_sell_volume_in_usd: Ok(Default::default()),
                    prev_sellers: Ok(Default::default()),
                    prev_sells: Ok(Default::default()),
                    prev_trades: Ok(Default::default()),
                    price_change_ratio_in_usd: Ok(Default::default()),
                    sell_volume: Ok(Default::default()),
                    sell_volume_in_native: Ok(Default::default()),
                    sell_volume_in_usd: Ok(Default::default()),
                    sellers: Ok(Default::default()),
                    sells: Ok(Default::default()),
                    total_volume_in_native: Ok(Default::default()),
                    total_volume_in_usd: Ok(Default::default()),
                    traders: Ok(Default::default()),
                    trades: Ok(Default::default()),
                    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::option::Option<::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::option::Option<::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<::std::option::Option<::std::string::String>>,
                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::option::Option<::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::option::Option<::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::option::Option<::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::option::Option<::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::option::Option<::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::option::Option<::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::option::Option<::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::option::Option<::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::option::Option<::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::option::Option<::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::option::Option<::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<::std::option::Option<::std::string::String>>,
                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::option::Option<::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::option::Option<::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::option::Option<::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::option::Option<::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::option::Option<::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::option::Option<::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::option::Option<::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::option::Option<::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::option::Option<::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::option::Option<::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::option::Option<::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::option::Option<::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::option::Option<::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::option::Option<::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::option::Option<::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::option::Option<::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::option::Option<::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::option::Option<::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::option::Option<::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::option::Option<::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::option::Option<::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::option::Option<::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::option::Option<::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::option::Option<::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::option::Option<::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::option::Option<::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::option::Option<::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::option::Option<::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::option::Option<::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::option::Option<::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::option::Option<::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::option::Option<::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::option::Option<::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::option::Option<::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::option::Option<::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::option::Option<::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::option::Option<::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<::std::option::Option<::std::string::String>>,
                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_timestamp: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            onchain_created_at: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::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_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_timestamp<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                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<::std::option::Option<::std::string::String>>,
                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_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_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 TokenTransfer {
            amount: ::std::result::Result<::std::string::String, ::std::string::String>,
            amount_in_usd: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            block_timestamp: ::std::result::Result<i64, ::std::string::String>,
            from_address: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            id: ::std::result::Result<::std::string::String, ::std::string::String>,
            status: ::std::result::Result<::std::string::String, ::std::string::String>,
            to_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<::std::string::String, ::std::string::String>,
        }
        impl ::std::default::Default for TokenTransfer {
            fn default() -> Self {
                Self {
                    amount: Err("no value supplied for amount".to_string()),
                    amount_in_usd: Ok(Default::default()),
                    block_timestamp: Err(
                        "no value supplied for block_timestamp".to_string(),
                    ),
                    from_address: Err("no value supplied for from_address".to_string()),
                    id: Err("no value supplied for id".to_string()),
                    status: Err("no value supplied for status".to_string()),
                    to_address: Err("no value supplied for to_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 TokenTransfer {
            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::option::Option<::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 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 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 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 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 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 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<::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<TokenTransfer> for super::TokenTransfer {
            type Error = super::error::ConversionError;
            fn try_from(
                value: TokenTransfer,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    amount: value.amount?,
                    amount_in_usd: value.amount_in_usd?,
                    block_timestamp: value.block_timestamp?,
                    from_address: value.from_address?,
                    id: value.id?,
                    status: value.status?,
                    to_address: value.to_address?,
                    token_address: value.token_address?,
                    transaction_signature: value.transaction_signature?,
                    type_: value.type_?,
                })
            }
        }
        impl ::std::convert::From<super::TokenTransfer> for TokenTransfer {
            fn from(value: super::TokenTransfer) -> Self {
                Self {
                    amount: Ok(value.amount),
                    amount_in_usd: Ok(value.amount_in_usd),
                    block_timestamp: Ok(value.block_timestamp),
                    from_address: Ok(value.from_address),
                    id: Ok(value.id),
                    status: Ok(value.status),
                    to_address: Ok(value.to_address),
                    token_address: Ok(value.token_address),
                    transaction_signature: Ok(value.transaction_signature),
                    type_: Ok(value.type_),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct TokenTransferTotal {
            total: ::std::result::Result<i64, ::std::string::String>,
        }
        impl ::std::default::Default for TokenTransferTotal {
            fn default() -> Self {
                Self {
                    total: Err("no value supplied for total".to_string()),
                }
            }
        }
        impl TokenTransferTotal {
            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<TokenTransferTotal> for super::TokenTransferTotal {
            type Error = super::error::ConversionError;
            fn try_from(
                value: TokenTransferTotal,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self { total: value.total? })
            }
        }
        impl ::std::convert::From<super::TokenTransferTotal> for TokenTransferTotal {
            fn from(value: super::TokenTransferTotal) -> Self {
                Self { total: Ok(value.total) }
            }
        }
        #[derive(Clone, Debug)]
        pub struct TopTrader {
            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 TopTrader {
            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 TopTrader {
            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<TopTrader> for super::TopTrader {
            type Error = super::error::ConversionError;
            fn try_from(
                value: TopTrader,
            ) -> ::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::TopTrader> for TopTrader {
            fn from(value: super::TopTrader) -> 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 TradeDetail {
            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::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            dex_program_address: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            dex_protocol_family: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            gas_fee: ::std::result::Result<
                ::std::option::Option<i64>,
                ::std::string::String,
            >,
            gas_fee_in_native: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            gas_fee_in_usd: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            history_bought_amount: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            history_sold_amount: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            is_open_or_close: ::std::result::Result<
                ::std::option::Option<i32>,
                ::std::string::String,
            >,
            maker_event_tags: ::std::result::Result<
                ::std::vec::Vec<::std::string::String>,
                ::std::string::String,
            >,
            market_cap_in_usd: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            pool_address: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            post_balance: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            realized_profit_in_usd: ::std::result::Result<
                ::std::option::Option<::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::option::Option<::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::option::Option<::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,
            >,
            trader_tags: ::std::result::Result<
                ::std::vec::Vec<::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 TradeDetail {
            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: Ok(Default::default()),
                    dex_program_address: Ok(Default::default()),
                    dex_protocol_family: Ok(Default::default()),
                    gas_fee: Ok(Default::default()),
                    gas_fee_in_native: Ok(Default::default()),
                    gas_fee_in_usd: Ok(Default::default()),
                    history_bought_amount: Ok(Default::default()),
                    history_sold_amount: Ok(Default::default()),
                    is_open_or_close: Ok(Default::default()),
                    maker_event_tags: Ok(Default::default()),
                    market_cap_in_usd: Ok(Default::default()),
                    pool_address: Err("no value supplied for pool_address".to_string()),
                    post_balance: Ok(Default::default()),
                    realized_profit_in_usd: Ok(Default::default()),
                    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: Ok(Default::default()),
                    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: Ok(Default::default()),
                    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()),
                    trader_tags: Ok(Default::default()),
                    transaction_signature: Err(
                        "no value supplied for transaction_signature".to_string(),
                    ),
                    type_: Err("no value supplied for type_".to_string()),
                }
            }
        }
        impl TradeDetail {
            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::option::Option<::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::option::Option<::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::option::Option<::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 gas_fee<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<i64>>,
                T::Error: ::std::fmt::Display,
            {
                self.gas_fee = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for gas_fee: {}", e)
                    });
                self
            }
            pub fn gas_fee_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.gas_fee_in_native = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for gas_fee_in_native: {}",
                            e
                        )
                    });
                self
            }
            pub fn gas_fee_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.gas_fee_in_usd = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for gas_fee_in_usd: {}", e
                        )
                    });
                self
            }
            pub fn history_bought_amount<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.history_bought_amount = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for history_bought_amount: {}",
                            e
                        )
                    });
                self
            }
            pub fn history_sold_amount<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.history_sold_amount = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for history_sold_amount: {}",
                            e
                        )
                    });
                self
            }
            pub fn is_open_or_close<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<i32>>,
                T::Error: ::std::fmt::Display,
            {
                self.is_open_or_close = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for is_open_or_close: {}", e
                        )
                    });
                self
            }
            pub fn maker_event_tags<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::vec::Vec<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.maker_event_tags = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for maker_event_tags: {}", e
                        )
                    });
                self
            }
            pub fn market_cap_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.market_cap_in_usd = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for market_cap_in_usd: {}",
                            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 post_balance<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::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 realized_profit_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.realized_profit_in_usd = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for realized_profit_in_usd: {}",
                            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::option::Option<::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::option::Option<::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 trader_tags<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::vec::Vec<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.trader_tags = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for trader_tags: {}", 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<TradeDetail> for super::TradeDetail {
            type Error = super::error::ConversionError;
            fn try_from(
                value: TradeDetail,
            ) -> ::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?,
                    gas_fee: value.gas_fee?,
                    gas_fee_in_native: value.gas_fee_in_native?,
                    gas_fee_in_usd: value.gas_fee_in_usd?,
                    history_bought_amount: value.history_bought_amount?,
                    history_sold_amount: value.history_sold_amount?,
                    is_open_or_close: value.is_open_or_close?,
                    maker_event_tags: value.maker_event_tags?,
                    market_cap_in_usd: value.market_cap_in_usd?,
                    pool_address: value.pool_address?,
                    post_balance: value.post_balance?,
                    realized_profit_in_usd: value.realized_profit_in_usd?,
                    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?,
                    trader_tags: value.trader_tags?,
                    transaction_signature: value.transaction_signature?,
                    type_: value.type_?,
                })
            }
        }
        impl ::std::convert::From<super::TradeDetail> for TradeDetail {
            fn from(value: super::TradeDetail) -> 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),
                    gas_fee: Ok(value.gas_fee),
                    gas_fee_in_native: Ok(value.gas_fee_in_native),
                    gas_fee_in_usd: Ok(value.gas_fee_in_usd),
                    history_bought_amount: Ok(value.history_bought_amount),
                    history_sold_amount: Ok(value.history_sold_amount),
                    is_open_or_close: Ok(value.is_open_or_close),
                    maker_event_tags: Ok(value.maker_event_tags),
                    market_cap_in_usd: Ok(value.market_cap_in_usd),
                    pool_address: Ok(value.pool_address),
                    post_balance: Ok(value.post_balance),
                    realized_profit_in_usd: Ok(value.realized_profit_in_usd),
                    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),
                    trader_tags: Ok(value.trader_tags),
                    transaction_signature: Ok(value.transaction_signature),
                    type_: Ok(value.type_),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct TraderGainersLosersItem {
            address: ::std::result::Result<::std::string::String, ::std::string::String>,
            chain: ::std::result::Result<::std::string::String, ::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 TraderGainersLosersItem {
            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 TraderGainersLosersItem {
            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 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<TraderGainersLosersItem>
        for super::TraderGainersLosersItem {
            type Error = super::error::ConversionError;
            fn try_from(
                value: TraderGainersLosersItem,
            ) -> ::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::TraderGainersLosersItem>
        for TraderGainersLosersItem {
            fn from(value: super::TraderGainersLosersItem) -> 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 TransferTotalResponse {
            total: ::std::result::Result<i64, ::std::string::String>,
        }
        impl ::std::default::Default for TransferTotalResponse {
            fn default() -> Self {
                Self {
                    total: Err("no value supplied for total".to_string()),
                }
            }
        }
        impl TransferTotalResponse {
            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<TransferTotalResponse>
        for super::TransferTotalResponse {
            type Error = super::error::ConversionError;
            fn try_from(
                value: TransferTotalResponse,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self { total: value.total? })
            }
        }
        impl ::std::convert::From<super::TransferTotalResponse>
        for TransferTotalResponse {
            fn from(value: super::TransferTotalResponse) -> Self {
                Self { total: Ok(value.total) }
            }
        }
        #[derive(Clone, Debug)]
        pub struct UpdateWebhookRequest {
            channels: ::std::result::Result<
                ::std::vec::Vec<super::WebhookChannel>,
                ::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,
            >,
            endpoint_id: ::std::result::Result<
                ::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<i32>,
                ::std::string::String,
            >,
            url: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for UpdateWebhookRequest {
            fn default() -> Self {
                Self {
                    channels: Ok(Default::default()),
                    description: Ok(Default::default()),
                    disabled: Ok(Default::default()),
                    endpoint_id: Err("no value supplied for endpoint_id".to_string()),
                    filter: Ok(Default::default()),
                    filter_types: Ok(Default::default()),
                    metadata: Ok(Default::default()),
                    rate_limit: Ok(Default::default()),
                    url: Ok(Default::default()),
                }
            }
        }
        impl UpdateWebhookRequest {
            pub fn channels<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::vec::Vec<super::WebhookChannel>>,
                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<::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 endpoint_id<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::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<i32>>,
                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<UpdateWebhookRequest>
        for super::UpdateWebhookRequest {
            type Error = super::error::ConversionError;
            fn try_from(
                value: UpdateWebhookRequest,
            ) -> ::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::UpdateWebhookRequest> for UpdateWebhookRequest {
            fn from(value: super::UpdateWebhookRequest) -> 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 WalletBalances {
            chain: ::std::result::Result<::std::string::String, ::std::string::String>,
            native_balance: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            native_balance_in_usd: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            tokens: ::std::result::Result<
                ::std::vec::Vec<super::TokenBalance>,
                ::std::string::String,
            >,
            total_value_in_usd: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            wallet_address: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for WalletBalances {
            fn default() -> Self {
                Self {
                    chain: Err("no value supplied for chain".to_string()),
                    native_balance: Ok(Default::default()),
                    native_balance_in_usd: Ok(Default::default()),
                    tokens: Err("no value supplied for tokens".to_string()),
                    total_value_in_usd: Ok(Default::default()),
                    wallet_address: Err(
                        "no value supplied for wallet_address".to_string(),
                    ),
                }
            }
        }
        impl WalletBalances {
            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 native_balance<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::option::Option<::std::string::String>>,
                T::Error: ::std::fmt::Display,
            {
                self.native_balance = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for native_balance: {}", e
                        )
                    });
                self
            }
            pub fn native_balance_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.native_balance_in_usd = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for native_balance_in_usd: {}",
                            e
                        )
                    });
                self
            }
            pub fn tokens<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::vec::Vec<super::TokenBalance>>,
                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_value_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.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<WalletBalances> for super::WalletBalances {
            type Error = super::error::ConversionError;
            fn try_from(
                value: WalletBalances,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    chain: value.chain?,
                    native_balance: value.native_balance?,
                    native_balance_in_usd: value.native_balance_in_usd?,
                    tokens: value.tokens?,
                    total_value_in_usd: value.total_value_in_usd?,
                    wallet_address: value.wallet_address?,
                })
            }
        }
        impl ::std::convert::From<super::WalletBalances> for WalletBalances {
            fn from(value: super::WalletBalances) -> Self {
                Self {
                    chain: Ok(value.chain),
                    native_balance: Ok(value.native_balance),
                    native_balance_in_usd: Ok(value.native_balance_in_usd),
                    tokens: Ok(value.tokens),
                    total_value_in_usd: Ok(value.total_value_in_usd),
                    wallet_address: Ok(value.wallet_address),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct WalletFirstTx {
            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<i32, ::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 WalletFirstTx {
            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 WalletFirstTx {
            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<i32>,
                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<WalletFirstTx> for super::WalletFirstTx {
            type Error = super::error::ConversionError;
            fn try_from(
                value: WalletFirstTx,
            ) -> ::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::WalletFirstTx> for WalletFirstTx {
            fn from(value: super::WalletFirstTx) -> 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 WalletNetWorth {
            chain: ::std::result::Result<::std::string::String, ::std::string::String>,
            token_count: ::std::result::Result<
                ::std::option::Option<i64>,
                ::std::string::String,
            >,
            total_value_in_native: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            total_value_in_usd: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            wallet_address: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for WalletNetWorth {
            fn default() -> Self {
                Self {
                    chain: Err("no value supplied for chain".to_string()),
                    token_count: Ok(Default::default()),
                    total_value_in_native: Ok(Default::default()),
                    total_value_in_usd: Ok(Default::default()),
                    wallet_address: Err(
                        "no value supplied for wallet_address".to_string(),
                    ),
                }
            }
        }
        impl WalletNetWorth {
            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 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 total_value_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.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::option::Option<::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<WalletNetWorth> for super::WalletNetWorth {
            type Error = super::error::ConversionError;
            fn try_from(
                value: WalletNetWorth,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    chain: value.chain?,
                    token_count: value.token_count?,
                    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::WalletNetWorth> for WalletNetWorth {
            fn from(value: super::WalletNetWorth) -> Self {
                Self {
                    chain: Ok(value.chain),
                    token_count: Ok(value.token_count),
                    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 WalletNetWorthChartResponse {
            current_timestamp: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            history: ::std::result::Result<
                ::std::vec::Vec<super::NetWorthHistoryItem>,
                ::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 WalletNetWorthChartResponse {
            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 WalletNetWorthChartResponse {
            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::NetWorthHistoryItem>>,
                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<WalletNetWorthChartResponse>
        for super::WalletNetWorthChartResponse {
            type Error = super::error::ConversionError;
            fn try_from(
                value: WalletNetWorthChartResponse,
            ) -> ::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::WalletNetWorthChartResponse>
        for WalletNetWorthChartResponse {
            fn from(value: super::WalletNetWorthChartResponse) -> 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::NetWorthByTokensItem>,
                ::std::string::String,
            >,
            end_cursor: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            has_next: ::std::result::Result<
                ::std::option::Option<bool>,
                ::std::string::String,
            >,
            has_prev: ::std::result::Result<
                ::std::option::Option<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,
            >,
            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()),
                    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::NetWorthByTokensItem>>,
                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<::std::option::Option<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<::std::option::Option<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 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?,
                    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),
                    wallet_address: Ok(value.wallet_address),
                }
            }
        }
        #[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::NetWorthByTokensItem>,
                ::std::string::String,
            >,
            end_cursor: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            has_next: ::std::result::Result<
                ::std::option::Option<bool>,
                ::std::string::String,
            >,
            has_prev: ::std::result::Result<
                ::std::option::Option<bool>,
                ::std::string::String,
            >,
            start_cursor: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::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_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::NetWorthByTokensItem>>,
                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<::std::option::Option<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<::std::option::Option<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_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_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_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 WalletNetWorthSummaryResponse {
            current_timestamp: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            wallets: ::std::result::Result<
                ::std::collections::HashMap<
                    ::std::string::String,
                    super::NetWorthSummaryValue,
                >,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for WalletNetWorthSummaryResponse {
            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 WalletNetWorthSummaryResponse {
            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::NetWorthSummaryValue,
                    >,
                >,
                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<WalletNetWorthSummaryResponse>
        for super::WalletNetWorthSummaryResponse {
            type Error = super::error::ConversionError;
            fn try_from(
                value: WalletNetWorthSummaryResponse,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    current_timestamp: value.current_timestamp?,
                    wallets: value.wallets?,
                })
            }
        }
        impl ::std::convert::From<super::WalletNetWorthSummaryResponse>
        for WalletNetWorthSummaryResponse {
            fn from(value: super::WalletNetWorthSummaryResponse) -> Self {
                Self {
                    current_timestamp: Ok(value.current_timestamp),
                    wallets: Ok(value.wallets),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct WalletPnlSummary {
            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<
                ::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_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 WalletPnlSummary {
            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 WalletPnlSummary {
            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<::std::string::String>,
                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<WalletPnlSummary> for super::WalletPnlSummary {
            type Error = super::error::ConversionError;
            fn try_from(
                value: WalletPnlSummary,
            ) -> ::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::WalletPnlSummary> for WalletPnlSummary {
            fn from(value: super::WalletPnlSummary) -> 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 WalletTransfer {
            amount: ::std::result::Result<::std::string::String, ::std::string::String>,
            amount_in_usd: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            block_timestamp: ::std::result::Result<i64, ::std::string::String>,
            from_address: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
            id: ::std::result::Result<::std::string::String, ::std::string::String>,
            to_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,
            >,
            transfer_type: ::std::result::Result<
                ::std::string::String,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for WalletTransfer {
            fn default() -> Self {
                Self {
                    amount: Err("no value supplied for amount".to_string()),
                    amount_in_usd: Ok(Default::default()),
                    block_timestamp: Err(
                        "no value supplied for block_timestamp".to_string(),
                    ),
                    from_address: Err("no value supplied for from_address".to_string()),
                    id: Err("no value supplied for id".to_string()),
                    to_address: Err("no value supplied for to_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(),
                    ),
                    transfer_type: Err("no value supplied for transfer_type".to_string()),
                }
            }
        }
        impl WalletTransfer {
            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::option::Option<::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 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 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 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 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 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 transfer_type<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.transfer_type = value
                    .try_into()
                    .map_err(|e| {
                        format!(
                            "error converting supplied value for transfer_type: {}", e
                        )
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<WalletTransfer> for super::WalletTransfer {
            type Error = super::error::ConversionError;
            fn try_from(
                value: WalletTransfer,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    amount: value.amount?,
                    amount_in_usd: value.amount_in_usd?,
                    block_timestamp: value.block_timestamp?,
                    from_address: value.from_address?,
                    id: value.id?,
                    to_address: value.to_address?,
                    token_address: value.token_address?,
                    transaction_signature: value.transaction_signature?,
                    transfer_type: value.transfer_type?,
                })
            }
        }
        impl ::std::convert::From<super::WalletTransfer> for WalletTransfer {
            fn from(value: super::WalletTransfer) -> Self {
                Self {
                    amount: Ok(value.amount),
                    amount_in_usd: Ok(value.amount_in_usd),
                    block_timestamp: Ok(value.block_timestamp),
                    from_address: Ok(value.from_address),
                    id: Ok(value.id),
                    to_address: Ok(value.to_address),
                    token_address: Ok(value.token_address),
                    transaction_signature: Ok(value.transaction_signature),
                    transfer_type: Ok(value.transfer_type),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct WalletsMapResponse {
            wallets: ::std::result::Result<
                ::std::collections::HashMap<::std::string::String, super::WalletFirstTx>,
                ::std::string::String,
            >,
        }
        impl ::std::default::Default for WalletsMapResponse {
            fn default() -> Self {
                Self {
                    wallets: Err("no value supplied for wallets".to_string()),
                }
            }
        }
        impl WalletsMapResponse {
            pub fn wallets<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<
                    ::std::collections::HashMap<
                        ::std::string::String,
                        super::WalletFirstTx,
                    >,
                >,
                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<WalletsMapResponse> for super::WalletsMapResponse {
            type Error = super::error::ConversionError;
            fn try_from(
                value: WalletsMapResponse,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self { wallets: value.wallets? })
            }
        }
        impl ::std::convert::From<super::WalletsMapResponse> for WalletsMapResponse {
            fn from(value: super::WalletsMapResponse) -> Self {
                Self { wallets: Ok(value.wallets) }
            }
        }
        #[derive(Clone, Debug)]
        pub struct Watchlist {
            items: ::std::result::Result<
                ::std::vec::Vec<super::WatchlistItem>,
                ::std::string::String,
            >,
            user_id: ::std::result::Result<::std::string::String, ::std::string::String>,
        }
        impl ::std::default::Default for Watchlist {
            fn default() -> Self {
                Self {
                    items: Err("no value supplied for items".to_string()),
                    user_id: Err("no value supplied for user_id".to_string()),
                }
            }
        }
        impl Watchlist {
            pub fn items<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::vec::Vec<super::WatchlistItem>>,
                T::Error: ::std::fmt::Display,
            {
                self.items = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for items: {}", e)
                    });
                self
            }
            pub fn user_id<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::string::String>,
                T::Error: ::std::fmt::Display,
            {
                self.user_id = value
                    .try_into()
                    .map_err(|e| {
                        format!("error converting supplied value for user_id: {}", e)
                    });
                self
            }
        }
        impl ::std::convert::TryFrom<Watchlist> for super::Watchlist {
            type Error = super::error::ConversionError;
            fn try_from(
                value: Watchlist,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    items: value.items?,
                    user_id: value.user_id?,
                })
            }
        }
        impl ::std::convert::From<super::Watchlist> for Watchlist {
            fn from(value: super::Watchlist) -> Self {
                Self {
                    items: Ok(value.items),
                    user_id: Ok(value.user_id),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct WatchlistAddResponseModel {
            success: ::std::result::Result<bool, ::std::string::String>,
        }
        impl ::std::default::Default for WatchlistAddResponseModel {
            fn default() -> Self {
                Self {
                    success: Err("no value supplied for success".to_string()),
                }
            }
        }
        impl WatchlistAddResponseModel {
            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<WatchlistAddResponseModel>
        for super::WatchlistAddResponseModel {
            type Error = super::error::ConversionError;
            fn try_from(
                value: WatchlistAddResponseModel,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self { success: value.success? })
            }
        }
        impl ::std::convert::From<super::WatchlistAddResponseModel>
        for WatchlistAddResponseModel {
            fn from(value: super::WatchlistAddResponseModel) -> Self {
                Self { success: Ok(value.success) }
            }
        }
        #[derive(Clone, Debug)]
        pub struct WatchlistItem {
            chain: ::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 WatchlistItem {
            fn default() -> Self {
                Self {
                    chain: Err("no value supplied for chain".to_string()),
                    wallet_address: Err(
                        "no value supplied for wallet_address".to_string(),
                    ),
                }
            }
        }
        impl WatchlistItem {
            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 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<WatchlistItem> for super::WatchlistItem {
            type Error = super::error::ConversionError;
            fn try_from(
                value: WatchlistItem,
            ) -> ::std::result::Result<Self, super::error::ConversionError> {
                Ok(Self {
                    chain: value.chain?,
                    wallet_address: value.wallet_address?,
                })
            }
        }
        impl ::std::convert::From<super::WatchlistItem> for WatchlistItem {
            fn from(value: super::WatchlistItem) -> Self {
                Self {
                    chain: Ok(value.chain),
                    wallet_address: Ok(value.wallet_address),
                }
            }
        }
        #[derive(Clone, Debug)]
        pub struct WebhookEndpoint {
            channels: ::std::result::Result<
                ::std::vec::Vec<super::WebhookChannel>,
                ::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::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<i32>,
                ::std::string::String,
            >,
            updated_at: ::std::result::Result<
                ::std::option::Option<::std::string::String>,
                ::std::string::String,
            >,
            url: ::std::result::Result<::std::string::String, ::std::string::String>,
        }
        impl ::std::default::Default for WebhookEndpoint {
            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: Err("no value supplied for id".to_string()),
                    metadata: Ok(Default::default()),
                    rate_limit: Ok(Default::default()),
                    updated_at: Ok(Default::default()),
                    url: Err("no value supplied for url".to_string()),
                }
            }
        }
        impl WebhookEndpoint {
            pub fn channels<T>(mut self, value: T) -> Self
            where
                T: ::std::convert::TryInto<::std::vec::Vec<super::WebhookChannel>>,
                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::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<i32>>,
                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::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<WebhookEndpoint> for super::WebhookEndpoint {
            type Error = super::error::ConversionError;
            fn try_from(
                value: WebhookEndpoint,
            ) -> ::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::WebhookEndpoint> for WebhookEndpoint {
            fn from(value: super::WebhookEndpoint) -> 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)]
/**Client for ChainStream API

ChainStream Unified API

Version: 2.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 {
        "2.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 {
    /**Blockchain - List

Get list of supported blockchains

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

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

Get the latest block information for a specific blockchain

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

Arguments:
- `chain`: A chain name listed in supported networks
```ignore
let response = client.get_latest_block()
    .chain(chain)
    .send()
    .await;
```*/
    pub fn get_latest_block(&self) -> builder::GetLatestBlock<'_> {
        builder::GetLatestBlock::new(self)
    }
    /**Dex - List

Obtain information about all DEXs on a specified blockchain.

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

Arguments:
- `chains`: Filter by blockchain networks
- `cursor`: Pagination cursor
- `dex_program`: Filter by DEX program address
- `direction`: Pagination direction (next or prev)
- `limit`: Number of results per page
```ignore
let response = client.list_dex()
    .chains(chains)
    .cursor(cursor)
    .dex_program(dex_program)
    .direction(direction)
    .limit(limit)
    .send()
    .await;
```*/
    pub fn list_dex(&self) -> builder::ListDex<'_> {
        builder::ListDex::new(self)
    }
    /**Dex - Create Token

Create a new token on the specified DEX

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

Arguments:
- `chain`: A chain name listed in supported networks
- `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)
    }
    /**Dex - Get Quote

Get DEX trading quote information

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

Arguments:
- `chain`: A chain name listed in supported networks
- `amount`: Trading amount
- `dex`: DEX protocol type
- `exact_in`: Exact input mode
- `input_mint`: Input token address
- `output_mint`: Output token address
- `slippage`: Slippage tolerance
```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)
    }
    /**Dex - Route

Calculate the best route for token swap considering price impact and fees. Returns the optimal path and a prepared transaction.

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

Arguments:
- `chain`: A chain name listed in supported networks
- `body`
```ignore
let response = client.route()
    .chain(chain)
    .body(body)
    .send()
    .await;
```*/
    pub fn route(&self) -> builder::Route<'_> {
        builder::Route::new(self)
    }
    /**Dex - Swap

Swap parameters including input token, output token, amount and slippage

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

Arguments:
- `chain`: A chain name listed in supported networks
- `body`
```ignore
let response = client.swap()
    .chain(chain)
    .body(body)
    .send()
    .await;
```*/
    pub fn swap(&self) -> builder::Swap<'_> {
        builder::Swap::new(self)
    }
    /**DexPool - Detail

Retrieve detailed information about a specific DEX pool

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

Arguments:
- `chain`: A chain name listed in supported networks
- `pool_address`: A pool address
```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)
    }
    /**DexPool - Liquidity Snapshots

Retrieve historical liquidity snapshots for a specific pool. If a time parameter is provided, returns the nearest snapshot before or at that time.

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

Arguments:
- `chain`: A chain name listed in supported networks
- `pool_address`: A pool address
- `cursor`: Pagination cursor
- `direction`: Pagination direction (next or prev)
- `limit`: Number of results per page
- `time`: Target Unix timestamp for snapshot query
```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)
    }
    /**DexScreener - Ads

Retrieve a list of paid DexScreener advertisements

Sends a `GET` request to `/v2/dexscr/{chain}/ads`

Arguments:
- `chain`: A chain name listed in supported networks
- `limit`: Number of results to return
```ignore
let response = client.get_dexscr_ads()
    .chain(chain)
    .limit(limit)
    .send()
    .await;
```*/
    pub fn get_dexscr_ads(&self) -> builder::GetDexscrAds<'_> {
        builder::GetDexscrAds::new(self)
    }
    /**DexScreener - Boosts

Retrieve a list of token boosts with spending amounts from DexScreener

Sends a `GET` request to `/v2/dexscr/{chain}/boosts`

Arguments:
- `chain`: A chain name listed in supported networks
- `limit`: Number of results to return
```ignore
let response = client.get_dexscr_boosts()
    .chain(chain)
    .limit(limit)
    .send()
    .await;
```*/
    pub fn get_dexscr_boosts(&self) -> builder::GetDexscrBoosts<'_> {
        builder::GetDexscrBoosts::new(self)
    }
    /**DexScreener - Link Updates

Retrieve recently updated token profile links from DexScreener

Sends a `GET` request to `/v2/dexscr/{chain}/link-updates`

Arguments:
- `chain`: A chain name listed in supported networks
- `limit`: Number of results to return
```ignore
let response = client.get_dexscr_link_updates()
    .chain(chain)
    .limit(limit)
    .send()
    .await;
```*/
    pub fn get_dexscr_link_updates(&self) -> builder::GetDexscrLinkUpdates<'_> {
        builder::GetDexscrLinkUpdates::new(self)
    }
    /**DexScreener - Token Info

Retrieve DexScreener ad, boost, and link update information for a specific token

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

Arguments:
- `chain`: A chain name listed in supported networks
- `token_address`: An address of a token
```ignore
let response = client.get_dexscr_token_info()
    .chain(chain)
    .token_address(token_address)
    .send()
    .await;
```*/
    pub fn get_dexscr_token_info(&self) -> builder::GetDexscrTokenInfo<'_> {
        builder::GetDexscrTokenInfo::new(self)
    }
    /**DexScreener - Trending

Retrieve trending meta categories from DexScreener

Sends a `GET` request to `/v2/dexscr/{chain}/trending`

Arguments:
- `chain`: A chain name listed in supported networks
- `limit`: Number of results to return
```ignore
let response = client.get_dexscr_trending()
    .chain(chain)
    .limit(limit)
    .send()
    .await;
```*/
    pub fn get_dexscr_trending(&self) -> builder::GetDexscrTrending<'_> {
        builder::GetDexscrTrending::new(self)
    }
    /**IPFS - Presign

Create a Presign URL for IPFS content

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

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

Retrieve the current status and result of a job by its ID

Sends a `GET` request to `/v2/job/{id}`

Arguments:
- `id`: Job identifier
```ignore
let response = client.get()
    .id(id)
    .send()
    .await;
```*/
    pub fn get(&self) -> builder::Get<'_> {
        builder::Get::new(self)
    }
    /**Job - Streaming

Subscribe to real-time job status updates via Server-Sent Events (SSE). The connection will remain open until the job completes or an error occurs

Sends a `GET` request to `/v2/job/{id}/streaming`

Arguments:
- `id`: Job identifier
```ignore
let response = client.streaming()
    .id(id)
    .send()
    .await;
```*/
    pub fn streaming(&self) -> builder::Streaming<'_> {
        builder::Streaming::new(self)
    }
    /**KYT - Register Address

Register an address for KYT monitoring

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

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

Retrieve risk assessment for a registered address

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

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

Register a transfer for KYT (Know Your Transaction) analysis

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

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

Retrieve alerts associated with a transfer

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

Arguments:
- `transfer_id`: 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)
    }
    /**KYT - Get Transfer Direct Exposure

Get direct exposure information for a transfer

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

Arguments:
- `transfer_id`: 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)
    }
    /**KYT - Get Transfer Network Identifications

Get network identifications for a transfer

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

Arguments:
- `transfer_id`: 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)
    }
    /**KYT - Get Transfer Summary

Retrieve summary information for a registered transfer

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

Arguments:
- `transfer_id`: 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)
    }
    /**KYT - Register Withdrawal

Register a withdrawal for KYT (Know Your Transaction) analysis

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

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

Get address identifications for a withdrawal

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

Arguments:
- `withdrawal_id`: 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)
    }
    /**KYT - Get Withdrawal Alerts

Retrieve alerts associated with a withdrawal

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

Arguments:
- `withdrawal_id`: 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)
    }
    /**KYT - Get Withdrawal Direct Exposure

Get direct exposure information for a withdrawal

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

Arguments:
- `withdrawal_id`: 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)
    }
    /**KYT - Get Withdrawal Fraud Assessment

Get fraud assessment results for a withdrawal

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

Arguments:
- `withdrawal_id`: 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)
    }
    /**KYT - Get Withdrawal Network Identifications

Get network identifications for a withdrawal

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

Arguments:
- `withdrawal_id`: 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)
    }
    /**KYT - Get Withdrawal Summary

Retrieve summary information for a registered withdrawal

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

Arguments:
- `withdrawal_id`: 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)
    }
    /**Ranking - FinalStretch Tokens

Return the finalStretch tokens

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

Arguments:
- `chain`: A chain name listed in supported networks
- `exclude_keywords`: Exclude Keywords
- `filters`: Filters
- `launchpad_platform`: Launchpad Platform
- `range_filters`: Filter field
- `search_keywords`: Search Keywords
- `sort_by`: Sort field
- `sort_direction`: Sort Direction
- `tag`: Ranking tag filter
```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)
    }
    /**Ranking - Hot Tokens

Retrieve a list of trending tokens

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

Arguments:
- `chain`: A chain name listed in supported networks
- `duration`: Duration of the ranking
- `exclude_keywords`: Exclude Keywords
- `filters`: Filters
- `launchpad_platform`: Launchpad Platform
- `range_filters`: Filter field
- `search_keywords`: Search Keywords
- `sort_by`: Sort field
- `sort_direction`: Sort Direction
- `tag`: Ranking tag filter
```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)
    }
    /**Ranking - Migrated Tokens

Return the migrated tokens

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

Arguments:
- `chain`: A chain name listed in supported networks
- `exclude_keywords`: Exclude Keywords
- `filters`: Filters
- `launchpad_platform`: Launchpad Platform
- `range_filters`: Filter field
- `search_keywords`: Search Keywords
- `sort_by`: Sort field
- `sort_direction`: Sort Direction
- `tag`: Ranking tag filter
```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)
    }
    /**Ranking - New Tokens

Return the latest 100 tokens

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

Arguments:
- `chain`: A chain name listed in supported networks
- `exclude_keywords`: Exclude Keywords
- `filters`: Filters
- `launchpad_platform`: Launchpad Platform
- `range_filters`: Filter field
- `search_keywords`: Search Keywords
- `sort_by`: Sort field
- `sort_direction`: Sort Direction
- `tag`: Ranking tag filter
```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)
    }
    /**Ranking - Stocks Tokens

Return the stocks tokens

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

Arguments:
- `chain`: A chain name listed in supported networks
- `exclude_keywords`: Exclude Keywords
- `filters`: Filters
- `launchpad_platform`: Launchpad Platform
- `range_filters`: Filter field
- `search_keywords`: Search Keywords
- `sort_by`: Sort field
- `sort_direction`: Sort Direction
- `tag`: Ranking tag filter
```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)
    }
    /**RedPacket - GetRedpackets

Get the redpackets list

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

Arguments:
- `chain`: Blockchain network for the red packet
- `creator`: Creator wallet address
- `cursor`: Pagination cursor
- `direction`: Pagination direction
- `limit`: Number of results per page
```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)
    }
    /**RedPacket - GetClaimsByAddress

Check the record of redpacket collection by the claimer address

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

Arguments:
- `address`: An address of a wallet
- `cursor`: Pagination cursor
- `direction`: Pagination direction
- `limit`: Number of results per page
```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)
    }
    /**RedPacket - GetRedpacketsByAddress

Get the redpackets list by the creator address

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

Arguments:
- `address`: An address of a wallet
- `cursor`: Pagination cursor
- `direction`: Pagination direction
- `limit`: Number of results per page
```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)
    }
    /**RedPacket - Claim

Claim tokens from an existing red packet

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

Arguments:
- `chain`: A chain name listed in supported networks
- `body`
```ignore
let response = client.claim_redpacket()
    .chain(chain)
    .body(body)
    .send()
    .await;
```*/
    pub fn claim_redpacket(&self) -> builder::ClaimRedpacket<'_> {
        builder::ClaimRedpacket::new(self)
    }
    /**RedPacket - Create

Create a new red packet with specified amount and quantity

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

Arguments:
- `chain`: A chain name listed in supported networks
- `body`
```ignore
let response = client.create_redpacket()
    .chain(chain)
    .body(body)
    .send()
    .await;
```*/
    pub fn create_redpacket(&self) -> builder::CreateRedpacket<'_> {
        builder::CreateRedpacket::new(self)
    }
    /**RedPacket - Send

Transactions related to redpacket

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

Arguments:
- `chain`: A chain name listed in supported networks
- `body`
```ignore
let response = client.redpacket_send()
    .chain(chain)
    .body(body)
    .send()
    .await;
```*/
    pub fn redpacket_send(&self) -> builder::RedpacketSend<'_> {
        builder::RedpacketSend::new(self)
    }
    /**RedPacket - Get

Query redpacket information

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

Arguments:
- `id`: Red packet identifier
```ignore
let response = client.get_redpacket()
    .id(id)
    .send()
    .await;
```*/
    pub fn get_redpacket(&self) -> builder::GetRedpacket<'_> {
        builder::GetRedpacket::new(self)
    }
    /**RedPacket - GetClaims

Check the record of redpacket collection

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

Arguments:
- `id`: Red packet identifier
- `cursor`: Pagination cursor
- `direction`: Pagination direction
- `limit`: Number of results per page
```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)
    }
    /**Token - Search

Search tokens by name, symbol or address

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

Arguments:
- `chains`: Chain filter
- `cursor`: Pagination cursor
- `direction`: Pagination direction (next or prev)
- `limit`: Number of results per page
- `mode`: Search mode: fast (default, returns basic fields) or normal (returns full token details)
- `protocols`: Protocol filter
- `q`: Search query string for token name, symbol or address
- `sort`: Sort direction
- `sort_by`: Field to sort by
```ignore
let response = client.search()
    .chains(chains)
    .cursor(cursor)
    .direction(direction)
    .limit(limit)
    .mode(mode)
    .protocols(protocols)
    .q(q)
    .sort(sort)
    .sort_by(sort_by)
    .send()
    .await;
```*/
    pub fn search(&self) -> builder::Search<'_> {
        builder::Search::new(self)
    }
    /**Token - Get Dev Tokens

Retrieve all tokens created by a specific developer address

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

Arguments:
- `chain`: A chain name listed in supported networks
- `dev_address`: An address of a user
- `cursor`: Pagination cursor
- `direction`: Pagination direction (next or prev)
- `limit`: Number of results per page
```ignore
let response = client.get_dev_tokens()
    .chain(chain)
    .dev_address(dev_address)
    .cursor(cursor)
    .direction(direction)
    .limit(limit)
    .send()
    .await;
```*/
    pub fn get_dev_tokens(&self) -> builder::GetDevTokens<'_> {
        builder::GetDevTokens::new(self)
    }
    /**Token - List (Filtered)

Get filtered token list with range conditions

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

Arguments:
- `chain`: A chain name listed in supported networks
- `cursor`: Pagination cursor
- `direction`: Pagination direction (next or prev)
- `limit`: Number of results per page
- `max_h1_buy_volume_in_usd`: Maximum 1h buy volume in USD
- `max_h1_buyers`: Maximum 1h buyer count
- `max_h1_buys`: Maximum 1h buy count
- `max_h1_price_change_ratio`: Maximum 1h price change ratio
- `max_h1_sell_volume_in_usd`: Maximum 1h sell volume in USD
- `max_h1_sellers`: Maximum 1h seller count
- `max_h1_sells`: Maximum 1h sell count
- `max_h1_trades`: Maximum 1h trade count
- `max_h1_volume_in_usd`: Maximum 1h volume in USD
- `max_h24_buy_volume_in_usd`: Maximum 24h buy volume in USD
- `max_h24_buyers`: Maximum 24h buyer count
- `max_h24_buys`: Maximum 24h buy count
- `max_h24_price_change_ratio`: Maximum 24h price change ratio
- `max_h24_sell_volume_in_usd`: Maximum 24h sell volume in USD
- `max_h24_sellers`: Maximum 24h seller count
- `max_h24_sells`: Maximum 24h sell count
- `max_h24_trades`: Maximum 24h trade count
- `max_h24_volume_in_usd`: Maximum 24h volume in USD
- `max_h4_buy_volume_in_usd`: Maximum 4h buy volume in USD
- `max_h4_buyers`: Maximum 4h buyer count
- `max_h4_buys`: Maximum 4h buy count
- `max_h4_price_change_ratio`: Maximum 4h price change ratio
- `max_h4_sell_volume_in_usd`: Maximum 4h sell volume in USD
- `max_h4_sellers`: Maximum 4h seller count
- `max_h4_sells`: Maximum 4h sell count
- `max_h4_trades`: Maximum 4h trade count
- `max_h4_volume_in_usd`: Maximum 4h volume in USD
- `max_m15_buy_volume_in_usd`: Maximum 15min buy volume in USD
- `max_m15_buyers`: Maximum 15min buyer count
- `max_m15_buys`: Maximum 15min buy count
- `max_m15_price_change_ratio`: Maximum 15min price change ratio
- `max_m15_sell_volume_in_usd`: Maximum 15min sell volume in USD
- `max_m15_sellers`: Maximum 15min seller count
- `max_m15_sells`: Maximum 15min sell count
- `max_m15_trades`: Maximum 15min trade count
- `max_m15_volume_in_usd`: Maximum 15min volume in USD
- `max_m1_buy_volume_in_usd`: Maximum 1min buy volume in USD
- `max_m1_buyers`: Maximum 1min buyer count
- `max_m1_buys`: Maximum 1min buy count
- `max_m1_price_change_ratio`: Maximum 1min price change ratio
- `max_m1_sell_volume_in_usd`: Maximum 1min sell volume in USD
- `max_m1_sellers`: Maximum 1min seller count
- `max_m1_sells`: Maximum 1min sell count
- `max_m1_trades`: Maximum 1min trade count
- `max_m1_volume_in_usd`: Maximum 1min volume in USD
- `max_m30_buy_volume_in_usd`: Maximum 30min buy volume in USD
- `max_m30_buyers`: Maximum 30min buyer count
- `max_m30_buys`: Maximum 30min buy count
- `max_m30_price_change_ratio`: Maximum 30min price change ratio
- `max_m30_sell_volume_in_usd`: Maximum 30min sell volume in USD
- `max_m30_sellers`: Maximum 30min seller count
- `max_m30_sells`: Maximum 30min sell count
- `max_m30_trades`: Maximum 30min trade count
- `max_m30_volume_in_usd`: Maximum 30min volume in USD
- `max_m5_buy_volume_in_usd`: Maximum 5min buy volume in USD
- `max_m5_buyers`: Maximum 5min buyer count
- `max_m5_buys`: Maximum 5min buy count
- `max_m5_price_change_ratio`: Maximum 5min price change ratio
- `max_m5_sell_volume_in_usd`: Maximum 5min sell volume in USD
- `max_m5_sellers`: Maximum 5min seller count
- `max_m5_sells`: Maximum 5min sell count
- `max_m5_trades`: Maximum 5min trade count
- `max_m5_volume_in_usd`: Maximum 5min volume in USD
- `min_h1_buy_volume_in_usd`: Minimum 1h buy volume in USD
- `min_h1_buyers`: Minimum 1h buyer count
- `min_h1_buys`: Minimum 1h buy count
- `min_h1_price_change_ratio`: Minimum 1h price change ratio
- `min_h1_sell_volume_in_usd`: Minimum 1h sell volume in USD
- `min_h1_sellers`: Minimum 1h seller count
- `min_h1_sells`: Minimum 1h sell count
- `min_h1_trades`: Minimum 1h trade count
- `min_h1_volume_in_usd`: Minimum 1h volume in USD
- `min_h24_buy_volume_in_usd`: Minimum 24h buy volume in USD
- `min_h24_buyers`: Minimum 24h buyer count
- `min_h24_buys`: Minimum 24h buy count
- `min_h24_price_change_ratio`: Minimum 24h price change ratio
- `min_h24_sell_volume_in_usd`: Minimum 24h sell volume in USD
- `min_h24_sellers`: Minimum 24h seller count
- `min_h24_sells`: Minimum 24h sell count
- `min_h24_trades`: Minimum 24h trade count
- `min_h24_volume_in_usd`: Minimum 24h volume in USD
- `min_h4_buy_volume_in_usd`: Minimum 4h buy volume in USD
- `min_h4_buyers`: Minimum 4h buyer count
- `min_h4_buys`: Minimum 4h buy count
- `min_h4_price_change_ratio`: Minimum 4h price change ratio
- `min_h4_sell_volume_in_usd`: Minimum 4h sell volume in USD
- `min_h4_sellers`: Minimum 4h seller count
- `min_h4_sells`: Minimum 4h sell count
- `min_h4_trades`: Minimum 4h trade count
- `min_h4_volume_in_usd`: Minimum 4h volume in USD
- `min_m15_buy_volume_in_usd`: Minimum 15min buy volume in USD
- `min_m15_buyers`: Minimum 15min buyer count
- `min_m15_buys`: Minimum 15min buy count
- `min_m15_price_change_ratio`: Minimum 15min price change ratio
- `min_m15_sell_volume_in_usd`: Minimum 15min sell volume in USD
- `min_m15_sellers`: Minimum 15min seller count
- `min_m15_sells`: Minimum 15min sell count
- `min_m15_trades`: Minimum 15min trade count
- `min_m15_volume_in_usd`: Minimum 15min volume in USD
- `min_m1_buy_volume_in_usd`: Minimum 1min buy volume in USD
- `min_m1_buyers`: Minimum 1min buyer count
- `min_m1_buys`: Minimum 1min buy count
- `min_m1_price_change_ratio`: Minimum 1min price change ratio
- `min_m1_sell_volume_in_usd`: Minimum 1min sell volume in USD
- `min_m1_sellers`: Minimum 1min seller count
- `min_m1_sells`: Minimum 1min sell count
- `min_m1_trades`: Minimum 1min trade count
- `min_m1_volume_in_usd`: Minimum 1min volume in USD
- `min_m30_buy_volume_in_usd`: Minimum 30min buy volume in USD
- `min_m30_buyers`: Minimum 30min buyer count
- `min_m30_buys`: Minimum 30min buy count
- `min_m30_price_change_ratio`: Minimum 30min price change ratio
- `min_m30_sell_volume_in_usd`: Minimum 30min sell volume in USD
- `min_m30_sellers`: Minimum 30min seller count
- `min_m30_sells`: Minimum 30min sell count
- `min_m30_trades`: Minimum 30min trade count
- `min_m30_volume_in_usd`: Minimum 30min volume in USD
- `min_m5_buy_volume_in_usd`: Minimum 5min buy volume in USD
- `min_m5_buyers`: Minimum 5min buyer count
- `min_m5_buys`: Minimum 5min buy count
- `min_m5_price_change_ratio`: Minimum 5min price change ratio
- `min_m5_sell_volume_in_usd`: Minimum 5min sell volume in USD
- `min_m5_sellers`: Minimum 5min seller count
- `min_m5_sells`: Minimum 5min sell count
- `min_m5_trades`: Minimum 5min trade count
- `min_m5_volume_in_usd`: Minimum 5min volume in USD
- `sort`: Sort direction (asc or desc)
- `sort_by`: Sort by field
```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)
    }
    /**Token - Market Data (Multi)

Get market data for multiple tokens

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

Arguments:
- `chain`: A chain name listed in supported networks
- `token_addresses`: A list of token addresses in string separated by commas (,). Maximum 100 token addresses allowed
```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)
    }
    /**Token - Metadata (Multi)

Get metadata for multiple tokens

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

Arguments:
- `chain`: A chain name listed in supported networks
- `token_addresses`: A list of token addresses in string separated by commas (,). Maximum 100 token addresses allowed
```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)
    }
    /**Token - Detail (Multi)

Get detail of tokens

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

Arguments:
- `chain`: A chain name listed in supported networks
- `filter_by`: DTO.TOKEN.REQUEST.FILTER_BY (JSON array of filter conditions)
- `sort_by`: Sort field
- `sort_direction`: Sort Direction
- `token_addresses`: A list of token addresses in string separated by commas (,). Maximum 100 token addresses allowed
```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)
    }
    /**Pair - Candles

Get OHLCV candlestick data for a trading pair (format: TOKEN_A_ADDRESS-TOKEN_B_ADDRESS)

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

Arguments:
- `chain`: A chain name listed in supported networks
- `pair`: Trading pair identifier (format: TOKEN_A_ADDRESS-TOKEN_B_ADDRESS). The pair will be automatically sorted
- `from`: Start timestamp (Unix epoch in seconds)
- `limit`: Number of candles to return
- `price_type`: Price type: usd (default) or native token price
- `resolution`: Time resolution for candle data
- `to`: End timestamp (Unix epoch in seconds)
```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)
    }
    /**Pool - Candles

Get OHLCV candlestick data for a specific liquidity pool

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

Arguments:
- `chain`: A chain name listed in supported networks
- `pool_address`: A pool address
- `from`: Start timestamp (Unix epoch in seconds)
- `limit`: Number of candles to return
- `price_type`: Price type: usd (default) or native token price
- `resolution`: Time resolution for candle data
- `to`: End timestamp (Unix epoch in seconds)
```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)
    }
    /**Token - Stats (Multi)

Get statistics for multiple tokens

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

Arguments:
- `chain`: A chain name listed in supported networks
- `token_addresses`: A list of token addresses in string separated by commas (,). Maximum 100 token addresses allowed
```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)
    }
    /**Token - Detail

Get detail of token

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

Arguments:
- `chain`: A chain name listed in supported networks
- `token_address`: An address of a token
```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)
    }
    /**Token - Candles

Get token price candles

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

Arguments:
- `chain`: A chain name listed in supported networks
- `token_address`: An address of a token
- `from`: Start timestamp (Unix epoch in seconds)
- `limit`: Number of candles to return
- `price_type`: Price type: usd (default) or native token price
- `resolution`: Time resolution for candle data
- `to`: End timestamp (Unix epoch in seconds)
```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)
    }
    /**Token - Creation

Get token creation information

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

Arguments:
- `chain`: A chain name listed in supported networks
- `token_address`: An address of a token
```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_HOLDER_TREND.SUMMARY

CONTROLLER.TOKEN.GET_HOLDER_TREND.DESCRIPTION

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

Arguments:
- `chain`: A chain name listed in supported networks
- `token_address`: An address of a token
- `from`: DTO.TOKEN.HOLDER_TREND.FROM Start timestamp in Unix milliseconds (default: 30 days ago)
- `resolution`: DTO.TOKEN.HOLDER_TREND.RESOLUTION Aggregation resolution: 1h (default) | 1d
- `to`: DTO.TOKEN.HOLDER_TREND.TO End timestamp in Unix milliseconds (default: now)
```ignore
let response = client.get_holder_trend()
    .chain(chain)
    .token_address(token_address)
    .from(from)
    .resolution(resolution)
    .to(to)
    .send()
    .await;
```*/
    pub fn get_holder_trend(&self) -> builder::GetHolderTrend<'_> {
        builder::GetHolderTrend::new(self)
    }
    /**Token - Holders

Get holders of a token

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

Arguments:
- `chain`: A chain name listed in supported networks
- `token_address`: An address of a token
- `cursor`: Pagination cursor
- `direction`: Pagination direction (next or prev)
- `limit`: Number of results per page
```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)
    }
    /**Token - Holders (Multi)

Get holders information for multiple wallet addresses

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

Arguments:
- `chain`: A chain name listed in supported networks
- `token_address`: An address of a token
- `wallet_addresses`: A list of wallet addresses in string separated by commas (,). Maximum 100 address addresses allowed
```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)
    }
    /**Token - Liquidity Snapshots

Retrieve historical liquidity snapshots for a token. If a time parameter is provided, returns the nearest snapshot before or at that time.

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

Arguments:
- `chain`: A chain name listed in supported networks
- `token_address`: An address of a token
- `cursor`: Pagination cursor
- `direction`: Pagination direction (next or prev)
- `limit`: Number of results per page
- `time`: Target Unix timestamp for liquidity snapshot query
```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)
    }
    /**Token - Market Cap

Get the market cap of a token

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

Arguments:
- `chain`: A chain name listed in supported networks
- `token_address`: An address of a token
```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)
    }
    /**Token - Metadata

Get metadata of token

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

Arguments:
- `chain`: A chain name listed in supported networks
- `token_address`: An address of a token
```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)
    }
    /**Token - Mint and Burn

Get mint and burn information for a token

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

Arguments:
- `chain`: A chain name listed in supported networks
- `token_address`: An address of a token
- `cursor`: Pagination cursor
- `direction`: Pagination direction (next or prev)
- `limit`: Number of results per page
- `type_`: Filter type for mint and burn operations
```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)
    }
    /**Token - Pools

Get all pools containing this token

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

Arguments:
- `chain`: A chain name listed in supported networks
- `token_address`: An address of a token
- `cursor`: Pagination cursor
- `direction`: Pagination direction (next or prev)
- `limit`: Number of results per page
- `max_tvl_in_sol`: Maximum TVL in SOL
- `max_tvl_in_usd`: Maximum TVL in USD
- `min_tvl_in_sol`: Minimum TVL in SOL
- `min_tvl_in_usd`: Minimum TVL in USD
- `sort_by`: Sort field (tvlInSol or tvlInUsd)
- `sort_direction`: Sort direction (asc or desc)
```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)
    }
    /**Token - Price by Time

Get token price at a specific timestamp

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

Arguments:
- `chain`: A chain name listed in supported networks
- `token_address`: An address of a token
- `timestamp`: Price timestamp (Unix epoch in seconds)
```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)
    }
    /**Token - Prices

Get historical price data for a token

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

Arguments:
- `chain`: A chain name listed in supported networks
- `token_address`: An address of a token
- `cursor`: Pagination cursor
- `direction`: Pagination direction (next or prev)
- `limit`: Number of results per page
```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)
    }
    /**Token - Security

Get token security information

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

Arguments:
- `chain`: A chain name listed in supported networks
- `token_address`: An address of a token
```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)
    }
    /**Get tokens similar to the specified token by image or name

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

Arguments:
- `chain`: Chain identifier
- `token_address`: Token address
- `limit`: Max results (1-100)
- `type_`: Similarity type: image or name
```ignore
let response = client.get_token_similar()
    .chain(chain)
    .token_address(token_address)
    .limit(limit)
    .type_(type_)
    .send()
    .await;
```*/
    pub fn get_token_similar(&self) -> builder::GetTokenSimilar<'_> {
        builder::GetTokenSimilar::new(self)
    }
    /**Token - Stats

Get token statistics

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

Arguments:
- `chain`: A chain name listed in supported networks
- `token_address`: An address of a token
```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)
    }
    /**Token - Top Holders

Get the top 20 holders for a token

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

Arguments:
- `chain`: A chain name listed in supported networks
- `token_address`: An address of a token
- `cursor`: Pagination cursor
- `direction`: Pagination direction (next or prev)
- `limit`: Number of results per page
```ignore
let response = client.get_top_holders()
    .chain(chain)
    .token_address(token_address)
    .cursor(cursor)
    .direction(direction)
    .limit(limit)
    .send()
    .await;
```*/
    pub fn get_top_holders(&self) -> builder::GetTopHolders<'_> {
        builder::GetTopHolders::new(self)
    }
    /**Token - Get Token Traders

Retrieve traders for a token by tag (fresh, sandwish, bundle, sniper, dev, pro, insider)

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

Arguments:
- `chain`: A chain name listed in supported networks
- `token_address`: An address of a token
- `tag`: Token trader tag (fresh, sandwish, bundle, sniper, dev, pro, insider)
- `cursor`: Pagination cursor
- `direction`: Pagination direction (next or prev)
- `limit`: Number of results per page
```ignore
let response = client.get_token_traders()
    .chain(chain)
    .token_address(token_address)
    .tag(tag)
    .cursor(cursor)
    .direction(direction)
    .limit(limit)
    .send()
    .await;
```*/
    pub fn get_token_traders(&self) -> builder::GetTokenTraders<'_> {
        builder::GetTokenTraders::new(self)
    }
    /**Token - Transfer Total

Get total count of transfers for a specific token with filters

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

Arguments:
- `chain`: A chain name listed in supported networks
- `token_address`: An address of a token
- `after_timestamp`: Filter transfers after this timestamp (Unix epoch seconds)
- `before_timestamp`: Filter transfers before this timestamp (Unix epoch seconds)
```ignore
let response = client.get_token_transfer_total()
    .chain(chain)
    .token_address(token_address)
    .after_timestamp(after_timestamp)
    .before_timestamp(before_timestamp)
    .send()
    .await;
```*/
    pub fn get_token_transfer_total(&self) -> builder::GetTokenTransferTotal<'_> {
        builder::GetTokenTransferTotal::new(self)
    }
    /**Token - Transfer List

Get transfer history for a specific token

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

Arguments:
- `chain`: A chain name listed in supported networks
- `token_address`: An address of a token
- `cursor`: Pagination cursor
- `direction`: Pagination direction (next or prev)
- `from_timestamp`: Start timestamp (Unix epoch in seconds)
- `limit`: Number of results per page
- `to_timestamp`: End timestamp (Unix epoch in seconds)
```ignore
let response = client.get_token_transfers()
    .chain(chain)
    .token_address(token_address)
    .cursor(cursor)
    .direction(direction)
    .from_timestamp(from_timestamp)
    .limit(limit)
    .to_timestamp(to_timestamp)
    .send()
    .await;
```*/
    pub fn get_token_transfers(&self) -> builder::GetTokenTransfers<'_> {
        builder::GetTokenTransfers::new(self)
    }
    /**Trade - List

Retrieve a list of token transactions

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

Arguments:
- `chain`: A chain name listed in supported networks
- `after_block_height`: Filter trades after this block height
- `after_timestamp`: End timestamp for filtering trades (Unix epoch in seconds)
- `before_block_height`: Filter trades before this block height
- `before_timestamp`: Start timestamp for filtering trades (Unix epoch in seconds)
- `cursor`: Pagination cursor
- `direction`: Pagination direction (next or prev)
- `limit`: Number of results per page
- `pool_address`: A pool address
- `token_address`: An address of a token
- `transactions_signature`: Transaction signature/hash
- `type_`: Trade type filter
- `wallet_address`: An address of a wallet
```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)
    }
    /**Activity - List

Get token activities including trades, liquidity operations, and other token-related activities

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

Arguments:
- `chain`: A chain name listed in supported networks
- `after_block_height`: Filter trades after this block height
- `after_timestamp`: End timestamp for filtering trades (Unix epoch in seconds)
- `before_block_height`: Filter trades before this block height
- `before_timestamp`: Start timestamp for filtering trades (Unix epoch in seconds)
- `cursor`: Pagination cursor
- `direction`: Pagination direction (next or prev)
- `limit`: Number of results per page
- `min_amount_usd`: Minimum trade value in USD (inclusive). Filters out small trades.
- `pool_address`: A pool address
- `sort_by`: DTO.TRADE.SORT_BY Sort by: timestamp (default) | totalUsd
- `token_address`: An address of a token
- `trader_tags`: Filter by trader tag(s). Comma-separated list from: kol, smart, sniper, bundle, dev, bluechip, insider, fresh.
Returns activities where the trader has ANY of the specified tags.
- `transactions_signature`: Transaction signature/hash
- `type_`: Activity type filter
- `wallet_address`: An address of a wallet
```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)
    .min_amount_usd(min_amount_usd)
    .pool_address(pool_address)
    .sort_by(sort_by)
    .token_address(token_address)
    .trader_tags(trader_tags)
    .transactions_signature(transactions_signature)
    .type_(type_)
    .wallet_address(wallet_address)
    .send()
    .await;
```*/
    pub fn get_activities(&self) -> builder::GetActivities<'_> {
        builder::GetActivities::new(self)
    }
    /**Trade - Top Traders

Get top traders for a specific token

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

Arguments:
- `chain`: A chain name listed in supported networks
- `cursor`: Pagination cursor
- `direction`: Pagination direction (next or prev)
- `limit`: Number of results per page
- `sort_by`: Field to sort trades by
- `sort_type`: Sort type for trade results
- `time_frame`: Time frame for filtering trades
- `token_address`: An address of a token
```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)
    }
    /**Trader - Gainers/Losers

Get top gainers or losers ranked by PnL

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

Arguments:
- `chain`: A chain name listed in supported networks
- `cursor`: Pagination cursor
- `direction`: Pagination direction (next or prev)
- `limit`: Number of results per page
- `resolution`: PnL time resolution (1d, 7d, or 30d)
- `sort_type`: Sort order (desc for gainers, asc for losers)
```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)
    }
    /**Transaction - Estimate Gas Limit

Estimate the gas limit for an EVM transaction

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

Arguments:
- `chain`: A chain name listed in supported networks
- `body`: Gas estimation parameters
```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)
    }
    /**Transaction - Gas Price

Get the current gas price for an EVM chain

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

Arguments:
- `chain`: A chain name listed in supported networks
```ignore
let response = client.get_gas_price()
    .chain(chain)
    .send()
    .await;
```*/
    pub fn get_gas_price(&self) -> builder::GetGasPrice<'_> {
        builder::GetGasPrice::new(self)
    }
    /**Transaction - Send

Submit a signed transaction to the blockchain

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

Arguments:
- `chain`: A chain name listed in supported networks
- `body`: Transaction parameters
```ignore
let response = client.send()
    .chain(chain)
    .body(body)
    .send()
    .await;
```*/
    pub fn send(&self) -> builder::Send<'_> {
        builder::Send::new(self)
    }
    /**Wallet - First Tx Funded

Get the first funded transaction for one or more wallets

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

Arguments:
- `chain`: A chain name listed in supported networks
- `wallet_addresses`: A list of wallet addresses in string separated by commas (,). Maximum 100 address addresses allowed
```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)
    }
    /**Wallet - Net Worth Summary (Multi)

Get current net worth summary for multiple wallets

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

Arguments:
- `chain`: A chain name listed in supported networks
- `wallet_addresses`: A list of wallet addresses in string separated by commas (,). Maximum 100 address addresses allowed
```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)
    }
    /**Wallet - PnL By Wallet

Get PnL for a specific token across multiple wallets

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

Arguments:
- `chain`: A chain name listed in supported networks
- `resolution`: DTO.WALLET.PNL_DETAILS.RESOLUTION
- `token_address`: An address of a token
- `wallet_addresses`: A list of wallet addresses in string separated by commas (,). Maximum 100 address addresses allowed
```ignore
let response = client.get_pnl_by_wallet()
    .chain(chain)
    .resolution(resolution)
    .token_address(token_address)
    .wallet_addresses(wallet_addresses)
    .send()
    .await;
```*/
    pub fn get_pnl_by_wallet(&self) -> builder::GetPnlByWallet<'_> {
        builder::GetPnlByWallet::new(self)
    }
    /**Wallet - Balance Updates

Get wallet balance change history with filtering and pagination

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

Arguments:
- `chain`: A chain name listed in supported networks
- `wallet_address`: An address of a wallet
- `change_type`: Balance change direction filter (INCREASE or DECREASE)
- `cursor`: Pagination cursor
- `direction`: Pagination direction (next or prev)
- `limit`: Number of results per page
- `time_from`: Start timestamp (Unix epoch in seconds)
- `time_to`: End timestamp (Unix epoch in seconds)
- `token_address`: An address of a token
- `type_`: Balance type filter (SOL for native, SPL for tokens)
```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)
    }
    /**Wallet - Calculate PNL

Calculate profit and loss for wallet tokens

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

Arguments:
- `chain`: A chain name listed in supported networks
- `wallet_address`: An address of a wallet
- `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)
    }
    /**Wallet - Net Worth

Get current net worth of a wallet including all token holdings with prices

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

Arguments:
- `chain`: A chain name listed in supported networks
- `wallet_address`: An address of a wallet
- `cursor`: Pagination cursor
- `direction`: Pagination direction (next or prev)
- `limit`: Number of results per page
```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)
    }
    /**Wallet - Net Worth Chart

Get historical net worth chart data for a wallet with hourly snapshots

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

Arguments:
- `chain`: A chain name listed in supported networks
- `wallet_address`: An address of a wallet
- `hours`: DTO.WALLET.NET_WORTH_CHART.HOURS (1-720, default 24)
```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)
    }
    /**Wallet - Net Worth Details

Get detailed net worth breakdown for a wallet, supporting both real-time and historical snapshots

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

Arguments:
- `chain`: A chain name listed in supported networks
- `wallet_address`: An address of a wallet
- `cursor`: Pagination cursor
- `direction`: Pagination direction (next or prev)
- `hours`: DTO.WALLET.NET_WORTH_DETAILS.HOURS (0=realtime, 1-720=historical snapshot, default 0)
- `limit`: Number of results per page
```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)
    }
    /**Wallet - Net Worth By Tokens

Get net worth breakdown by tokens for a wallet

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

Arguments:
- `chain`: A chain name listed in supported networks
- `wallet_address`: An address of a wallet
- `token_addresses`: A list of token addresses in string separated by commas (,). Maximum 100 token addresses allowed
```ignore
let response = client.get_net_worth_by_tokens()
    .chain(chain)
    .wallet_address(wallet_address)
    .token_addresses(token_addresses)
    .send()
    .await;
```*/
    pub fn get_net_worth_by_tokens(&self) -> builder::GetNetWorthByTokens<'_> {
        builder::GetNetWorthByTokens::new(self)
    }
    /**Wallet - PnL Summary

Get aggregated profit and loss summary for a wallet

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

Arguments:
- `chain`: A chain name listed in supported networks
- `wallet_address`: An address of a wallet
- `resolution`: PnL time resolution (1d, 7d, 30d, or all)
```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)
    }
    /**Wallet - PnL By Token

Get PnL for specific tokens in a wallet

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

Arguments:
- `chain`: A chain name listed in supported networks
- `wallet_address`: An address of a wallet
- `resolution`: DTO.WALLET.PNL_DETAILS.RESOLUTION
- `token_addresses`: A list of token addresses in string separated by commas (,). Maximum 100 token addresses allowed
```ignore
let response = client.get_pnl_by_token()
    .chain(chain)
    .wallet_address(wallet_address)
    .resolution(resolution)
    .token_addresses(token_addresses)
    .send()
    .await;
```*/
    pub fn get_pnl_by_token(&self) -> builder::GetPnlByToken<'_> {
        builder::GetPnlByToken::new(self)
    }
    /**Wallet - PnL Details

Get per-token PnL breakdown for a wallet

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

Arguments:
- `chain`: A chain name listed in supported networks
- `wallet_address`: An address of a wallet
- `cursor`: Pagination cursor
- `direction`: Pagination direction (next or prev)
- `limit`: Number of results per page
- `resolution`: DTO.WALLET.PNL_DETAILS.RESOLUTION
```ignore
let response = client.get_pnl_details()
    .chain(chain)
    .wallet_address(wallet_address)
    .cursor(cursor)
    .direction(direction)
    .limit(limit)
    .resolution(resolution)
    .send()
    .await;
```*/
    pub fn get_pnl_details(&self) -> builder::GetPnlDetails<'_> {
        builder::GetPnlDetails::new(self)
    }
    /**Wallet - Tokens Balance

Get token balances for a wallet with current prices

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

Arguments:
- `chain`: A chain name listed in supported networks
- `wallet_address`: An address of a wallet
- `cursor`: Pagination cursor
- `direction`: Pagination direction (next or prev)
- `limit`: Number of results per page
```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)
    }
    /**Wallet - Transfer Total

Get total count of transfers for a wallet with optional token filter

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

Arguments:
- `chain`: A chain name listed in supported networks
- `wallet_address`: An address of a wallet
- `from_timestamp`: Filter transfers after this timestamp (Unix epoch seconds)
- `max_token_amount`: Maximum token amount filter (inclusive)
- `max_token_amount_in_usd`: Maximum token amount in USD filter (inclusive)
- `min_token_amount`: Minimum token amount filter (inclusive)
- `min_token_amount_in_usd`: Minimum token amount in USD filter (inclusive)
- `to_timestamp`: Filter transfers before this timestamp (Unix epoch seconds)
- `token_address`: An address of a token
```ignore
let response = client.get_wallet_transfer_total()
    .chain(chain)
    .wallet_address(wallet_address)
    .from_timestamp(from_timestamp)
    .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)
    .to_timestamp(to_timestamp)
    .token_address(token_address)
    .send()
    .await;
```*/
    pub fn get_wallet_transfer_total(&self) -> builder::GetWalletTransferTotal<'_> {
        builder::GetWalletTransferTotal::new(self)
    }
    /**Wallet - Transfer List

Get transfer history for a wallet with optional token filter

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

Arguments:
- `chain`: A chain name listed in supported networks
- `wallet_address`: An address of a wallet
- `cursor`: Pagination cursor
- `direction`: Pagination direction (next or prev)
- `from_timestamp`: Filter transfers after this timestamp (Unix epoch seconds)
- `limit`: Number of results per page
- `max_token_amount`: Maximum token amount filter (inclusive)
- `max_token_amount_in_usd`: Maximum token amount in USD filter (inclusive)
- `min_token_amount`: Minimum token amount filter (inclusive)
- `min_token_amount_in_usd`: Minimum token amount in USD filter (inclusive)
- `to_timestamp`: Filter transfers before this timestamp (Unix epoch seconds)
- `token_address`: An address of a token
```ignore
let response = client.get_wallet_transfers()
    .chain(chain)
    .wallet_address(wallet_address)
    .cursor(cursor)
    .direction(direction)
    .from_timestamp(from_timestamp)
    .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)
    .to_timestamp(to_timestamp)
    .token_address(token_address)
    .send()
    .await;
```*/
    pub fn get_wallet_transfers(&self) -> builder::GetWalletTransfers<'_> {
        builder::GetWalletTransfers::new(self)
    }
    /**Watchlist - Add

Add the wallet address to the watchlist. Only the addresses in the watchlist have PNL data

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

Arguments:
- `chain`: A chain name listed in supported networks
- `wallet_address`: An address of a wallet
```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)
    }
    /**Endpoint - List

Get list of webhook endpoints

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

Arguments:
- `iterator`: Pagination iterator
- `limit`: Number of results per page
- `order`: Sort 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)
    }
    /**Endpoint - Create

Create a new webhook endpoint

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

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

Update webhook endpoint configuration

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

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

Get webhook endpoint details

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

Arguments:
- `id`: Endpoint ID
```ignore
let response = client.get_endpoint()
    .id(id)
    .send()
    .await;
```*/
    pub fn get_endpoint(&self) -> builder::GetEndpoint<'_> {
        builder::GetEndpoint::new(self)
    }
    /**Endpoint - Delete

Delete a webhook endpoint

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

Arguments:
- `id`: Endpoint ID
```ignore
let response = client.delete_endpoint()
    .id(id)
    .send()
    .await;
```*/
    pub fn delete_endpoint(&self) -> builder::DeleteEndpoint<'_> {
        builder::DeleteEndpoint::new(self)
    }
    /**Endpoint - Get Secret

Get webhook endpoint secret

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

Arguments:
- `id`: Endpoint ID
```ignore
let response = client.get_endpoint_secret()
    .id(id)
    .send()
    .await;
```*/
    pub fn get_endpoint_secret(&self) -> builder::GetEndpointSecret<'_> {
        builder::GetEndpointSecret::new(self)
    }
    /**Endpoint - Rotate Secret

Rotate the secret key for a webhook endpoint

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

Arguments:
- `id`: Endpoint ID
```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 `/v2/blockchain`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<::std::vec::Vec<types::Blockchain>>, Error<()>> {
            let Self { client } = self;
            let url = format!("{}/v2/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 `/v2/blockchain/{chain}/latest_block`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::BlockchainLatestBlock>, Error<()>> {
            let Self { client, chain } = self;
            let chain = chain.map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v2/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>,
        cursor: Result<Option<::std::string::String>, String>,
        dex_program: Result<Option<::std::string::String>, String>,
        direction: Result<Option<types::PageDirection>, String>,
        limit: Result<Option<i64>, String>,
    }
    impl<'a> ListDex<'a> {
        pub fn new(client: &'a super::Client) -> Self {
            Self {
                client: client,
                chains: Ok(None),
                cursor: Ok(None),
                dex_program: Ok(None),
                direction: 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 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 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 direction<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::PageDirection>,
        {
            self.direction = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `PageDirection` for direction 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
        }
        ///Sends a `GET` request to `/v2/dex`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::PageResponseDex>, Error<()>> {
            let Self { client, chains, cursor, dex_program, direction, limit } = self;
            let chains = chains.map_err(Error::InvalidRequest)?;
            let cursor = cursor.map_err(Error::InvalidRequest)?;
            let dex_program = dex_program.map_err(Error::InvalidRequest)?;
            let direction = direction.map_err(Error::InvalidRequest)?;
            let limit = limit.map_err(Error::InvalidRequest)?;
            let url = format!("{}/v2/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("cursor", &cursor))
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "dexProgram",
                        &dex_program,
                    ),
                )
                .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: "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 `/v2/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!(
                "{}/v2/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 `/v2/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!(
                "{}/v2/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 `/v2/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!(
                "{}/v2/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 `/v2/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!(
                "{}/v2/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 `/v2/dexpools/{chain}/{poolAddress}`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::DexPoolDetail>, 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!(
                "{}/v2/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::PageDirection>, String>,
        limit: Result<Option<i64>, 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::PageDirection>,
        {
            self.direction = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `PageDirection` for direction 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 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 `/v2/dexpools/{chain}/{poolAddress}/snapshots`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::PageResponseDexPoolSnapshot>, 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!(
                "{}/v2/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::get_dexscr_ads`]

[`Client::get_dexscr_ads`]: super::Client::get_dexscr_ads*/
    #[derive(Debug, Clone)]
    pub struct GetDexscrAds<'a> {
        client: &'a super::Client,
        chain: Result<types::ChainSymbol, String>,
        limit: Result<Option<::std::num::NonZeroU64>, String>,
    }
    impl<'a> GetDexscrAds<'a> {
        pub fn new(client: &'a super::Client) -> Self {
            Self {
                client: client,
                chain: Err("chain was not initialized".to_string()),
                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 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 `/v2/dexscr/{chain}/ads`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<::std::vec::Vec<types::DexscrAd>>, Error<()>> {
            let Self { client, chain, limit } = self;
            let chain = chain.map_err(Error::InvalidRequest)?;
            let limit = limit.map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v2/dexscr/{}/ads", 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("limit", &limit))
                .headers(header_map)
                .build()?;
            let info = OperationInfo {
                operation_id: "get_dexscr_ads",
            };
            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_dexscr_boosts`]

[`Client::get_dexscr_boosts`]: super::Client::get_dexscr_boosts*/
    #[derive(Debug, Clone)]
    pub struct GetDexscrBoosts<'a> {
        client: &'a super::Client,
        chain: Result<types::ChainSymbol, String>,
        limit: Result<Option<::std::num::NonZeroU64>, String>,
    }
    impl<'a> GetDexscrBoosts<'a> {
        pub fn new(client: &'a super::Client) -> Self {
            Self {
                client: client,
                chain: Err("chain was not initialized".to_string()),
                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 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 `/v2/dexscr/{chain}/boosts`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<::std::vec::Vec<types::DexscrBoost>>, Error<()>> {
            let Self { client, chain, limit } = self;
            let chain = chain.map_err(Error::InvalidRequest)?;
            let limit = limit.map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v2/dexscr/{}/boosts", 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("limit", &limit))
                .headers(header_map)
                .build()?;
            let info = OperationInfo {
                operation_id: "get_dexscr_boosts",
            };
            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_dexscr_link_updates`]

[`Client::get_dexscr_link_updates`]: super::Client::get_dexscr_link_updates*/
    #[derive(Debug, Clone)]
    pub struct GetDexscrLinkUpdates<'a> {
        client: &'a super::Client,
        chain: Result<types::ChainSymbol, String>,
        limit: Result<Option<::std::num::NonZeroU64>, String>,
    }
    impl<'a> GetDexscrLinkUpdates<'a> {
        pub fn new(client: &'a super::Client) -> Self {
            Self {
                client: client,
                chain: Err("chain was not initialized".to_string()),
                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 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 `/v2/dexscr/{chain}/link-updates`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<::std::vec::Vec<types::DexscrLinkUpdate>>, Error<()>> {
            let Self { client, chain, limit } = self;
            let chain = chain.map_err(Error::InvalidRequest)?;
            let limit = limit.map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v2/dexscr/{}/link-updates", 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("limit", &limit))
                .headers(header_map)
                .build()?;
            let info = OperationInfo {
                operation_id: "get_dexscr_link_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::get_dexscr_token_info`]

[`Client::get_dexscr_token_info`]: super::Client::get_dexscr_token_info*/
    #[derive(Debug, Clone)]
    pub struct GetDexscrTokenInfo<'a> {
        client: &'a super::Client,
        chain: Result<types::ChainSymbol, String>,
        token_address: Result<::std::string::String, String>,
    }
    impl<'a> GetDexscrTokenInfo<'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 `/v2/dexscr/{chain}/token/{tokenAddress}`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::DexscrTokenInfo>, 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!(
                "{}/v2/dexscr/{}/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_dexscr_token_info",
            };
            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_dexscr_trending`]

[`Client::get_dexscr_trending`]: super::Client::get_dexscr_trending*/
    #[derive(Debug, Clone)]
    pub struct GetDexscrTrending<'a> {
        client: &'a super::Client,
        chain: Result<types::ChainSymbol, String>,
        limit: Result<Option<::std::num::NonZeroU64>, String>,
    }
    impl<'a> GetDexscrTrending<'a> {
        pub fn new(client: &'a super::Client) -> Self {
            Self {
                client: client,
                chain: Err("chain was not initialized".to_string()),
                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 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 `/v2/dexscr/{chain}/trending`
        pub async fn send(
            self,
        ) -> Result<
            ResponseValue<::std::vec::Vec<types::DexscrTrendingMeta>>,
            Error<()>,
        > {
            let Self { client, chain, limit } = self;
            let chain = chain.map_err(Error::InvalidRequest)?;
            let limit = limit.map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v2/dexscr/{}/trending", 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("limit", &limit))
                .headers(header_map)
                .build()?;
            let info = OperationInfo {
                operation_id: "get_dexscr_trending",
            };
            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 `/v2/ipfs/presign`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::PresignResponseModel>, Error<()>> {
            let Self { client } = self;
            let url = format!("{}/v2/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 `/v2/job/{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!(
                "{}/v2/job/{}", 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 `/v2/job/{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!(
                "{}/v2/job/{}/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::KytRegisterAddressInput, 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::KytRegisterAddressInput>,
            <V as std::convert::TryInto<
                types::KytRegisterAddressInput,
            >>::Error: std::fmt::Display,
        {
            self.body = value
                .try_into()
                .map(From::from)
                .map_err(|s| {
                    format!(
                        "conversion to `KytRegisterAddressInput` for body failed: {}", s
                    )
                });
            self
        }
        pub fn body_map<F>(mut self, f: F) -> Self
        where
            F: std::ops::FnOnce(
                types::builder::KytRegisterAddressInput,
            ) -> types::builder::KytRegisterAddressInput,
        {
            self.body = self.body.map(f);
            self
        }
        ///Sends a `POST` request to `/v2/kyt/address`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::KytRegisterAddressResponse>, Error<()>> {
            let Self { client, body } = self;
            let body = body
                .and_then(|v| {
                    types::KytRegisterAddressInput::try_from(v)
                        .map_err(|e| e.to_string())
                })
                .map_err(Error::InvalidRequest)?;
            let url = format!("{}/v2/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 `/v2/kyt/addresses/{address}/risk`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::KytAddressRiskResponse>, Error<()>> {
            let Self { client, address } = self;
            let address = address.map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v2/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::KytRegisterTransferInput, 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::KytRegisterTransferInput>,
            <V as std::convert::TryInto<
                types::KytRegisterTransferInput,
            >>::Error: std::fmt::Display,
        {
            self.body = value
                .try_into()
                .map(From::from)
                .map_err(|s| {
                    format!(
                        "conversion to `KytRegisterTransferInput` for body failed: {}", s
                    )
                });
            self
        }
        pub fn body_map<F>(mut self, f: F) -> Self
        where
            F: std::ops::FnOnce(
                types::builder::KytRegisterTransferInput,
            ) -> types::builder::KytRegisterTransferInput,
        {
            self.body = self.body.map(f);
            self
        }
        ///Sends a `POST` request to `/v2/kyt/transfer`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::KytTransferBaseResponse>, Error<()>> {
            let Self { client, body } = self;
            let body = body
                .and_then(|v| {
                    types::KytRegisterTransferInput::try_from(v)
                        .map_err(|e| e.to_string())
                })
                .map_err(Error::InvalidRequest)?;
            let url = format!("{}/v2/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 `/v2/kyt/transfers/{transferId}/alerts`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::KytAlertsResponse>, Error<()>> {
            let Self { client, transfer_id } = self;
            let transfer_id = transfer_id.map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v2/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 `/v2/kyt/transfers/{transferId}/exposures/direct`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::KytDirectExposureResponse>, Error<()>> {
            let Self { client, transfer_id } = self;
            let transfer_id = transfer_id.map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v2/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 `/v2/kyt/transfers/{transferId}/network-identifications`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::KytNetworkIdentificationsResponse>, Error<()>> {
            let Self { client, transfer_id } = self;
            let transfer_id = transfer_id.map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v2/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 `/v2/kyt/transfers/{transferId}/summary`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::KytTransferBaseResponse>, Error<()>> {
            let Self { client, transfer_id } = self;
            let transfer_id = transfer_id.map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v2/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::KytRegisterWithdrawalInput, 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::KytRegisterWithdrawalInput>,
            <V as std::convert::TryInto<
                types::KytRegisterWithdrawalInput,
            >>::Error: std::fmt::Display,
        {
            self.body = value
                .try_into()
                .map(From::from)
                .map_err(|s| {
                    format!(
                        "conversion to `KytRegisterWithdrawalInput` for body failed: {}",
                        s
                    )
                });
            self
        }
        pub fn body_map<F>(mut self, f: F) -> Self
        where
            F: std::ops::FnOnce(
                types::builder::KytRegisterWithdrawalInput,
            ) -> types::builder::KytRegisterWithdrawalInput,
        {
            self.body = self.body.map(f);
            self
        }
        ///Sends a `POST` request to `/v2/kyt/withdrawal`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::KytWithdrawalBaseResponse>, Error<()>> {
            let Self { client, body } = self;
            let body = body
                .and_then(|v| {
                    types::KytRegisterWithdrawalInput::try_from(v)
                        .map_err(|e| e.to_string())
                })
                .map_err(Error::InvalidRequest)?;
            let url = format!("{}/v2/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 `/v2/kyt/withdrawal/{withdrawalId}/address-identifications`
        pub async fn send(
            self,
        ) -> Result<
            ResponseValue<types::KytWithdrawalAddressIdentificationsResponse>,
            Error<()>,
        > {
            let Self { client, withdrawal_id } = self;
            let withdrawal_id = withdrawal_id.map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v2/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 `/v2/kyt/withdrawal/{withdrawalId}/alerts`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::KytAlertsResponse>, Error<()>> {
            let Self { client, withdrawal_id } = self;
            let withdrawal_id = withdrawal_id.map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v2/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 `/v2/kyt/withdrawal/{withdrawalId}/exposures/direct`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::KytDirectExposureResponse>, Error<()>> {
            let Self { client, withdrawal_id } = self;
            let withdrawal_id = withdrawal_id.map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v2/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 `/v2/kyt/withdrawal/{withdrawalId}/fraud-assessment`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::KytFraudAssessmentResponse>, Error<()>> {
            let Self { client, withdrawal_id } = self;
            let withdrawal_id = withdrawal_id.map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v2/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 `/v2/kyt/withdrawal/{withdrawalId}/network-identifications`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::KytNetworkIdentificationsResponse>, Error<()>> {
            let Self { client, withdrawal_id } = self;
            let withdrawal_id = withdrawal_id.map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v2/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 `/v2/kyt/withdrawal/{withdrawalId}/summary`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::KytWithdrawalBaseResponse>, Error<()>> {
            let Self { client, withdrawal_id } = self;
            let withdrawal_id = withdrawal_id.map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v2/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::RangeFilterCondition>>,
            String,
        >,
        search_keywords: Result<Option<::std::vec::Vec<::std::string::String>>, String>,
        sort_by: Result<Option<types::TokenField>, String>,
        sort_direction: Result<Option<types::SortDirection>, String>,
        tag: Result<Option<types::RankingTag>, 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::RangeFilterCondition>>,
        {
            self.range_filters = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: vec :: Vec < RangeFilterCondition >` 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::TokenField>,
        {
            self.sort_by = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `TokenField` for sort_by failed".to_string()
                });
            self
        }
        pub fn sort_direction<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::SortDirection>,
        {
            self.sort_direction = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `SortDirection` for sort_direction failed".to_string()
                });
            self
        }
        pub fn tag<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::RankingTag>,
        {
            self.tag = value
                .try_into()
                .map(Some)
                .map_err(|_| "conversion to `RankingTag` for tag failed".to_string());
            self
        }
        ///Sends a `GET` request to `/v2/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!(
                "{}/v2/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::RankingDuration, 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::RangeFilterCondition>>,
            String,
        >,
        search_keywords: Result<Option<::std::vec::Vec<::std::string::String>>, String>,
        sort_by: Result<Option<types::TokenField>, String>,
        sort_direction: Result<Option<types::SortDirection>, String>,
        tag: Result<Option<types::RankingTag>, 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::RankingDuration>,
        {
            self.duration = value
                .try_into()
                .map_err(|_| {
                    "conversion to `RankingDuration` 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::RangeFilterCondition>>,
        {
            self.range_filters = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: vec :: Vec < RangeFilterCondition >` 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::TokenField>,
        {
            self.sort_by = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `TokenField` for sort_by failed".to_string()
                });
            self
        }
        pub fn sort_direction<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::SortDirection>,
        {
            self.sort_direction = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `SortDirection` for sort_direction failed".to_string()
                });
            self
        }
        pub fn tag<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::RankingTag>,
        {
            self.tag = value
                .try_into()
                .map(Some)
                .map_err(|_| "conversion to `RankingTag` for tag failed".to_string());
            self
        }
        ///Sends a `GET` request to `/v2/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!(
                "{}/v2/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::RangeFilterCondition>>,
            String,
        >,
        search_keywords: Result<Option<::std::vec::Vec<::std::string::String>>, String>,
        sort_by: Result<Option<types::TokenField>, String>,
        sort_direction: Result<Option<types::SortDirection>, String>,
        tag: Result<Option<types::RankingTag>, 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::RangeFilterCondition>>,
        {
            self.range_filters = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: vec :: Vec < RangeFilterCondition >` 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::TokenField>,
        {
            self.sort_by = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `TokenField` for sort_by failed".to_string()
                });
            self
        }
        pub fn sort_direction<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::SortDirection>,
        {
            self.sort_direction = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `SortDirection` for sort_direction failed".to_string()
                });
            self
        }
        pub fn tag<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::RankingTag>,
        {
            self.tag = value
                .try_into()
                .map(Some)
                .map_err(|_| "conversion to `RankingTag` for tag failed".to_string());
            self
        }
        ///Sends a `GET` request to `/v2/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!(
                "{}/v2/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::RangeFilterCondition>>,
            String,
        >,
        search_keywords: Result<Option<::std::vec::Vec<::std::string::String>>, String>,
        sort_by: Result<Option<types::TokenField>, String>,
        sort_direction: Result<Option<types::SortDirection>, String>,
        tag: Result<Option<types::RankingTag>, 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::RangeFilterCondition>>,
        {
            self.range_filters = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: vec :: Vec < RangeFilterCondition >` 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::TokenField>,
        {
            self.sort_by = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `TokenField` for sort_by failed".to_string()
                });
            self
        }
        pub fn sort_direction<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::SortDirection>,
        {
            self.sort_direction = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `SortDirection` for sort_direction failed".to_string()
                });
            self
        }
        pub fn tag<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::RankingTag>,
        {
            self.tag = value
                .try_into()
                .map(Some)
                .map_err(|_| "conversion to `RankingTag` for tag failed".to_string());
            self
        }
        ///Sends a `GET` request to `/v2/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!(
                "{}/v2/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::RangeFilterCondition>>,
            String,
        >,
        search_keywords: Result<Option<::std::vec::Vec<::std::string::String>>, String>,
        sort_by: Result<Option<types::TokenField>, String>,
        sort_direction: Result<Option<types::SortDirection>, String>,
        tag: Result<Option<types::RankingTag>, 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::RangeFilterCondition>>,
        {
            self.range_filters = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: vec :: Vec < RangeFilterCondition >` 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::TokenField>,
        {
            self.sort_by = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `TokenField` for sort_by failed".to_string()
                });
            self
        }
        pub fn sort_direction<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::SortDirection>,
        {
            self.sort_direction = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `SortDirection` for sort_direction failed".to_string()
                });
            self
        }
        pub fn tag<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::RankingTag>,
        {
            self.tag = value
                .try_into()
                .map(Some)
                .map_err(|_| "conversion to `RankingTag` for tag failed".to_string());
            self
        }
        ///Sends a `GET` request to `/v2/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!(
                "{}/v2/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::ChainSymbol>, String>,
        creator: Result<Option<::std::string::String>, String>,
        cursor: Result<Option<::std::string::String>, String>,
        direction: Result<Option<types::PageDirection>, String>,
        limit: Result<Option<i64>, 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::ChainSymbol>,
        {
            self.chain = value
                .try_into()
                .map(Some)
                .map_err(|_| "conversion to `ChainSymbol` 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<types::PageDirection>,
        {
            self.direction = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `PageDirection` for direction 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
        }
        ///Sends a `GET` request to `/v2/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!("{}/v2/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<types::PageDirection>, String>,
        limit: Result<Option<i64>, 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<types::PageDirection>,
        {
            self.direction = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `PageDirection` for direction 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
        }
        ///Sends a `GET` request to `/v2/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!(
                "{}/v2/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<types::PageDirection>, String>,
        limit: Result<Option<i64>, 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<types::PageDirection>,
        {
            self.direction = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `PageDirection` for direction 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
        }
        ///Sends a `GET` request to `/v2/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!(
                "{}/v2/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::ClaimRedPacketRequest, 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::ClaimRedPacketRequest>,
            <V as std::convert::TryInto<
                types::ClaimRedPacketRequest,
            >>::Error: std::fmt::Display,
        {
            self.body = value
                .try_into()
                .map(From::from)
                .map_err(|s| {
                    format!(
                        "conversion to `ClaimRedPacketRequest` for body failed: {}", s
                    )
                });
            self
        }
        pub fn body_map<F>(mut self, f: F) -> Self
        where
            F: std::ops::FnOnce(
                types::builder::ClaimRedPacketRequest,
            ) -> types::builder::ClaimRedPacketRequest,
        {
            self.body = self.body.map(f);
            self
        }
        ///Sends a `POST` request to `/v2/redpacket/{chain}/claim`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::ClaimRedPacketResponse>, Error<()>> {
            let Self { client, chain, body } = self;
            let chain = chain.map_err(Error::InvalidRequest)?;
            let body = body
                .and_then(|v| {
                    types::ClaimRedPacketRequest::try_from(v).map_err(|e| e.to_string())
                })
                .map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v2/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::CreateRedPacketRequest, 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::CreateRedPacketRequest>,
            <V as std::convert::TryInto<
                types::CreateRedPacketRequest,
            >>::Error: std::fmt::Display,
        {
            self.body = value
                .try_into()
                .map(From::from)
                .map_err(|s| {
                    format!(
                        "conversion to `CreateRedPacketRequest` for body failed: {}", s
                    )
                });
            self
        }
        pub fn body_map<F>(mut self, f: F) -> Self
        where
            F: std::ops::FnOnce(
                types::builder::CreateRedPacketRequest,
            ) -> types::builder::CreateRedPacketRequest,
        {
            self.body = self.body.map(f);
            self
        }
        ///Sends a `POST` request to `/v2/redpacket/{chain}/create`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::CreateRedPacketResponse>, Error<()>> {
            let Self { client, chain, body } = self;
            let chain = chain.map_err(Error::InvalidRequest)?;
            let body = body
                .and_then(|v| {
                    types::CreateRedPacketRequest::try_from(v).map_err(|e| e.to_string())
                })
                .map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v2/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::RedPacketSendTxRequest, 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::RedPacketSendTxRequest>,
            <V as std::convert::TryInto<
                types::RedPacketSendTxRequest,
            >>::Error: std::fmt::Display,
        {
            self.body = value
                .try_into()
                .map(From::from)
                .map_err(|s| {
                    format!(
                        "conversion to `RedPacketSendTxRequest` for body failed: {}", s
                    )
                });
            self
        }
        pub fn body_map<F>(mut self, f: F) -> Self
        where
            F: std::ops::FnOnce(
                types::builder::RedPacketSendTxRequest,
            ) -> types::builder::RedPacketSendTxRequest,
        {
            self.body = self.body.map(f);
            self
        }
        ///Sends a `POST` request to `/v2/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::RedPacketSendTxRequest::try_from(v).map_err(|e| e.to_string())
                })
                .map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v2/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 `/v2/redpacket/{id}`
        pub async fn send(self) -> Result<ResponseValue<types::RedPacket>, Error<()>> {
            let Self { client, id } = self;
            let id = id.map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v2/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<types::PageDirection>, String>,
        limit: Result<Option<i64>, 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<types::PageDirection>,
        {
            self.direction = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `PageDirection` for direction 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
        }
        ///Sends a `GET` request to `/v2/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!(
                "{}/v2/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::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::PageDirection>, String>,
        limit: Result<Option<i64>, String>,
        mode: Result<Option<types::SearchMode>, String>,
        protocols: Result<Option<::std::vec::Vec<::std::string::String>>, String>,
        q: Result<Option<::std::string::String>, String>,
        sort: Result<Option<types::SortDirection>, 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),
                mode: 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::PageDirection>,
        {
            self.direction = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `PageDirection` for direction 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 mode<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::SearchMode>,
        {
            self.mode = value
                .try_into()
                .map(Some)
                .map_err(|_| "conversion to `SearchMode` for mode 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<::std::string::String>,
        {
            self.q = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for q failed".to_string()
                });
            self
        }
        pub fn sort<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::SortDirection>,
        {
            self.sort = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `SortDirection` 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 `/v2/token/search`
        pub async fn send(self) -> Result<ResponseValue<types::TokenPage>, Error<()>> {
            let Self {
                client,
                chains,
                cursor,
                direction,
                limit,
                mode,
                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 mode = mode.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!("{}/v2/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("mode", &mode))
                .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>,
        cursor: Result<Option<::std::string::String>, String>,
        direction: Result<Option<types::PageDirection>, String>,
        limit: Result<Option<i64>, 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()),
                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 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
        }
        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::PageDirection>,
        {
            self.direction = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `PageDirection` for direction 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
        }
        ///Sends a `GET` request to `/v2/token/{chain}/dev/{devAddress}/tokens`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::PageResponseDevToken>, Error<()>> {
            let Self { client, chain, dev_address, cursor, direction, limit } = self;
            let chain = chain.map_err(Error::InvalidRequest)?;
            let dev_address = dev_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!(
                "{}/v2/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"),
                )
                .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_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::PageDirection>, String>,
        limit: Result<Option<i64>, 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::SortDirection>, String>,
        sort_by: Result<Option<types::TokenListSortField>, 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::PageDirection>,
        {
            self.direction = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `PageDirection` for direction 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 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::SortDirection>,
        {
            self.sort = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `SortDirection` for sort failed".to_string()
                });
            self
        }
        pub fn sort_by<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::TokenListSortField>,
        {
            self.sort_by = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `TokenListSortField` for sort_by failed".to_string()
                });
            self
        }
        ///Sends a `GET` request to `/v2/token/{chain}/list`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::PageResponseToken>, 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!(
                "{}/v2/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 `/v2/token/{chain}/marketData/multi`
        pub async fn send(
            self,
        ) -> Result<
            ResponseValue<
                ::std::collections::HashMap<
                    ::std::string::String,
                    types::GetMarketDataMultiResponseValue,
                >,
            >,
            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!(
                "{}/v2/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 `/v2/token/{chain}/metadata/multi`
        pub async fn send(
            self,
        ) -> Result<
            ResponseValue<
                ::std::collections::HashMap<
                    ::std::string::String,
                    types::GetMetadataMultiResponseValue,
                >,
            >,
            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!(
                "{}/v2/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::string::String>, String>,
        sort_by: Result<Option<types::TokenField>, String>,
        sort_direction: Result<Option<types::SortDirection>, 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::string::String>,
        {
            self.filter_by = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for filter_by failed"
                        .to_string()
                });
            self
        }
        pub fn sort_by<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::TokenField>,
        {
            self.sort_by = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `TokenField` for sort_by failed".to_string()
                });
            self
        }
        pub fn sort_direction<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::SortDirection>,
        {
            self.sort_direction = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `SortDirection` 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 `/v2/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!(
                "{}/v2/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 `/v2/token/{chain}/pair/{pair}/candles`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<::std::vec::Vec<types::TokenCandle>>, 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!(
                "{}/v2/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 `/v2/token/{chain}/pool/{poolAddress}/candles`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<::std::vec::Vec<types::TokenCandle>>, 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!(
                "{}/v2/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 `/v2/token/{chain}/stats/multi`
        pub async fn send(
            self,
        ) -> Result<
            ResponseValue<
                ::std::collections::HashMap<
                    ::std::string::String,
                    types::GetStatsMultiResponseValue,
                >,
            >,
            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!(
                "{}/v2/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 `/v2/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!(
                "{}/v2/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 `/v2/token/{chain}/{tokenAddress}/candles`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<::std::vec::Vec<types::TokenCandle>>, 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!(
                "{}/v2/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 `/v2/token/{chain}/{tokenAddress}/creation`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::TokenCreation>, 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!(
                "{}/v2/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_holder_trend`]

[`Client::get_holder_trend`]: super::Client::get_holder_trend*/
    #[derive(Debug, Clone)]
    pub struct GetHolderTrend<'a> {
        client: &'a super::Client,
        chain: Result<types::ChainSymbol, String>,
        token_address: Result<::std::string::String, String>,
        from: Result<Option<i64>, String>,
        resolution: Result<Option<::std::string::String>, String>,
        to: Result<Option<i64>, String>,
    }
    impl<'a> GetHolderTrend<'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),
                resolution: Ok(None),
                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 resolution<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.resolution = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` 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 `/v2/token/{chain}/{tokenAddress}/holderTrend`
        pub async fn send(
            self,
        ) -> Result<
            ResponseValue<::std::vec::Vec<types::TokenHolderTrendPoint>>,
            Error<()>,
        > {
            let Self { client, chain, token_address, from, 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 resolution = resolution.map_err(Error::InvalidRequest)?;
            let to = to.map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v2/token/{}/{}/holderTrend", 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(
                        "resolution",
                        &resolution,
                    ),
                )
                .query(&progenitor_middleware_client::QueryParam::new("to", &to))
                .headers(header_map)
                .build()?;
            let info = OperationInfo {
                operation_id: "get_holder_trend",
            };
            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::PageDirection>, String>,
        limit: Result<Option<i64>, 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::PageDirection>,
        {
            self.direction = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `PageDirection` for direction 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
        }
        ///Sends a `GET` request to `/v2/token/{chain}/{tokenAddress}/holders`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::PageResponseTokenHolder>, 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!(
                "{}/v2/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 `/v2/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!(
                "{}/v2/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::PageDirection>, String>,
        limit: Result<Option<i64>, 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::PageDirection>,
        {
            self.direction = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `PageDirection` for direction 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 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 `/v2/token/{chain}/{tokenAddress}/liquiditySnapshots`
        pub async fn send(
            self,
        ) -> Result<
            ResponseValue<types::PageResponseTokenLiquiditySnapshot>,
            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!(
                "{}/v2/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 `/v2/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!(
                "{}/v2/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 `/v2/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!(
                "{}/v2/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::PageDirection>, String>,
        limit: Result<Option<i64>, String>,
        type_: Result<Option<types::MintBurnType>, 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::PageDirection>,
        {
            self.direction = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `PageDirection` for direction 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 type_<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::MintBurnType>,
        {
            self.type_ = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `MintBurnType` for type_ failed".to_string()
                });
            self
        }
        ///Sends a `GET` request to `/v2/token/{chain}/{tokenAddress}/mintAndBurn`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::PageResponseTokenMintBurn>, 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!(
                "{}/v2/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::PageDirection>, String>,
        limit: Result<Option<i64>, 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::PoolSortField>, String>,
        sort_direction: Result<Option<types::SortDirection>, 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::PageDirection>,
        {
            self.direction = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `PageDirection` for direction 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 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::PoolSortField>,
        {
            self.sort_by = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `PoolSortField` for sort_by failed".to_string()
                });
            self
        }
        pub fn sort_direction<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::SortDirection>,
        {
            self.sort_direction = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `SortDirection` for sort_direction failed".to_string()
                });
            self
        }
        ///Sends a `GET` request to `/v2/token/{chain}/{tokenAddress}/pools`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::PageResponseDexPool>, 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!(
                "{}/v2/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 `/v2/token/{chain}/{tokenAddress}/price`
        pub async fn send(self) -> Result<ResponseValue<types::TokenPrice>, 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!(
                "{}/v2/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::PageDirection>, String>,
        limit: Result<Option<i64>, 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::PageDirection>,
        {
            self.direction = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `PageDirection` for direction 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
        }
        ///Sends a `GET` request to `/v2/token/{chain}/{tokenAddress}/prices`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::PageResponseTokenPrice>, 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!(
                "{}/v2/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 `/v2/token/{chain}/{tokenAddress}/security`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::TokenSecurityResponse>, 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!(
                "{}/v2/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_token_similar`]

[`Client::get_token_similar`]: super::Client::get_token_similar*/
    #[derive(Debug, Clone)]
    pub struct GetTokenSimilar<'a> {
        client: &'a super::Client,
        chain: Result<::std::string::String, String>,
        token_address: Result<::std::string::String, String>,
        limit: Result<Option<i64>, String>,
        type_: Result<Option<types::SimilarType>, String>,
    }
    impl<'a> GetTokenSimilar<'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()),
                limit: Ok(None),
                type_: Ok(None),
            }
        }
        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 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 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 type_<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::SimilarType>,
        {
            self.type_ = value
                .try_into()
                .map(Some)
                .map_err(|_| "conversion to `SimilarType` for type_ failed".to_string());
            self
        }
        ///Sends a `GET` request to `/v2/token/{chain}/{tokenAddress}/similar`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<::std::vec::Vec<types::Token>>, Error<()>> {
            let Self { client, chain, token_address, limit, type_ } = self;
            let chain = chain.map_err(Error::InvalidRequest)?;
            let token_address = token_address.map_err(Error::InvalidRequest)?;
            let limit = limit.map_err(Error::InvalidRequest)?;
            let type_ = type_.map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v2/token/{}/{}/similar", 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("limit", &limit))
                .query(&progenitor_middleware_client::QueryParam::new("type", &type_))
                .headers(header_map)
                .build()?;
            let info = OperationInfo {
                operation_id: "get_token_similar",
            };
            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 `/v2/token/{chain}/{tokenAddress}/stats`
        pub async fn send(self) -> Result<ResponseValue<types::TokenStats>, 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!(
                "{}/v2/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>,
        cursor: Result<Option<::std::string::String>, String>,
        direction: Result<Option<types::PageDirection>, String>,
        limit: Result<Option<i64>, 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()),
                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::PageDirection>,
        {
            self.direction = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `PageDirection` for direction 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
        }
        ///Sends a `GET` request to `/v2/token/{chain}/{tokenAddress}/topHolders`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::PageResponseTokenHolder>, 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!(
                "{}/v2/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"),
                )
                .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_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>,
        cursor: Result<Option<::std::string::String>, String>,
        direction: Result<Option<types::PageDirection>, String>,
        limit: Result<Option<i64>, 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()),
                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 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
        }
        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::PageDirection>,
        {
            self.direction = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `PageDirection` for direction 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
        }
        ///Sends a `GET` request to `/v2/token/{chain}/{tokenAddress}/traders/{tag}`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::PageResponseTokenTrader>, Error<()>> {
            let Self { client, chain, token_address, tag, cursor, direction, limit } = 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 cursor = cursor.map_err(Error::InvalidRequest)?;
            let direction = direction.map_err(Error::InvalidRequest)?;
            let limit = limit.map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v2/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"),
                )
                .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_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>,
    }
    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),
            }
        }
        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
        }
        ///Sends a `GET` request to `/v2/token/{chain}/{tokenAddress}/transfer-total`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::TokenTransferTotal>, Error<()>> {
            let Self {
                client,
                chain,
                token_address,
                after_timestamp,
                before_timestamp,
            } = 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 url = format!(
                "{}/v2/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,
                    ),
                )
                .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>,
        cursor: Result<Option<::std::string::String>, String>,
        direction: Result<Option<types::PageDirection>, String>,
        from_timestamp: Result<Option<i64>, String>,
        limit: Result<Option<i64>, String>,
        to_timestamp: Result<Option<i64>, 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()),
                cursor: Ok(None),
                direction: Ok(None),
                from_timestamp: Ok(None),
                limit: Ok(None),
                to_timestamp: 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::PageDirection>,
        {
            self.direction = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `PageDirection` for direction failed".to_string()
                });
            self
        }
        pub fn from_timestamp<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<i64>,
        {
            self.from_timestamp = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `i64` for from_timestamp 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 to_timestamp<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<i64>,
        {
            self.to_timestamp = value
                .try_into()
                .map(Some)
                .map_err(|_| "conversion to `i64` for to_timestamp failed".to_string());
            self
        }
        ///Sends a `GET` request to `/v2/token/{chain}/{tokenAddress}/transfers`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::PageResponseTokenTransfer>, Error<()>> {
            let Self {
                client,
                chain,
                token_address,
                cursor,
                direction,
                from_timestamp,
                limit,
                to_timestamp,
            } = 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 from_timestamp = from_timestamp.map_err(Error::InvalidRequest)?;
            let limit = limit.map_err(Error::InvalidRequest)?;
            let to_timestamp = to_timestamp.map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v2/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("cursor", &cursor))
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "direction",
                        &direction,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "fromTimestamp",
                        &from_timestamp,
                    ),
                )
                .query(&progenitor_middleware_client::QueryParam::new("limit", &limit))
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "toTimestamp",
                        &to_timestamp,
                    ),
                )
                .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::PageDirection>, String>,
        limit: Result<Option<i64>, 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::TradeType>, 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::PageDirection>,
        {
            self.direction = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `PageDirection` for direction 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 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::TradeType>,
        {
            self.type_ = value
                .try_into()
                .map(Some)
                .map_err(|_| "conversion to `TradeType` 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 `/v2/trade/{chain}`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::PageResponseTradeDetail>, 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!(
                "{}/v2/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::PageDirection>, String>,
        limit: Result<Option<i64>, String>,
        min_amount_usd: Result<Option<::std::string::String>, String>,
        pool_address: Result<Option<::std::string::String>, String>,
        sort_by: Result<Option<types::ActivitySortBy>, String>,
        token_address: Result<Option<::std::string::String>, String>,
        trader_tags: Result<Option<::std::string::String>, String>,
        transactions_signature: Result<Option<::std::string::String>, String>,
        type_: Result<Option<types::ActivityType>, 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),
                min_amount_usd: Ok(None),
                pool_address: Ok(None),
                sort_by: Ok(None),
                token_address: Ok(None),
                trader_tags: 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::PageDirection>,
        {
            self.direction = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `PageDirection` for direction 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 min_amount_usd<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.min_amount_usd = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for min_amount_usd 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 sort_by<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::ActivitySortBy>,
        {
            self.sort_by = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `ActivitySortBy` for sort_by 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 trader_tags<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<::std::string::String>,
        {
            self.trader_tags = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `:: std :: string :: String` for trader_tags 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::ActivityType>,
        {
            self.type_ = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `ActivityType` 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 `/v2/trade/{chain}/activities`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::PageResponseTradeDetail>, Error<()>> {
            let Self {
                client,
                chain,
                after_block_height,
                after_timestamp,
                before_block_height,
                before_timestamp,
                cursor,
                direction,
                limit,
                min_amount_usd,
                pool_address,
                sort_by,
                token_address,
                trader_tags,
                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 min_amount_usd = min_amount_usd.map_err(Error::InvalidRequest)?;
            let pool_address = pool_address.map_err(Error::InvalidRequest)?;
            let sort_by = sort_by.map_err(Error::InvalidRequest)?;
            let token_address = token_address.map_err(Error::InvalidRequest)?;
            let trader_tags = trader_tags.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!(
                "{}/v2/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(
                        "minAmountUsd",
                        &min_amount_usd,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "poolAddress",
                        &pool_address,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new("sortBy", &sort_by),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "tokenAddress",
                        &token_address,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "traderTags",
                        &trader_tags,
                    ),
                )
                .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::PageDirection>, String>,
        limit: Result<Option<i64>, String>,
        sort_by: Result<Option<types::TopTraderSortBy>, String>,
        sort_type: Result<Option<types::SortDirection>, String>,
        time_frame: Result<Option<types::TimeFrame>, 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::PageDirection>,
        {
            self.direction = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `PageDirection` for direction 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 sort_by<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::TopTraderSortBy>,
        {
            self.sort_by = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `TopTraderSortBy` for sort_by failed".to_string()
                });
            self
        }
        pub fn sort_type<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::SortDirection>,
        {
            self.sort_type = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `SortDirection` for sort_type failed".to_string()
                });
            self
        }
        pub fn time_frame<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::TimeFrame>,
        {
            self.time_frame = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `TimeFrame` 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 `/v2/trade/{chain}/top-traders`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::PageResponseTopTrader>, 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!(
                "{}/v2/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::PageDirection>, String>,
        limit: Result<Option<i64>, String>,
        resolution: Result<Option<types::TraderPnlResolution>, String>,
        sort_type: Result<Option<types::SortDirection>, 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::PageDirection>,
        {
            self.direction = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `PageDirection` for direction 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 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::SortDirection>,
        {
            self.sort_type = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `SortDirection` for sort_type failed".to_string()
                });
            self
        }
        ///Sends a `GET` request to `/v2/trade/{chain}/trader-gainers-losers`
        pub async fn send(
            self,
        ) -> Result<
            ResponseValue<types::PageResponseTraderGainersLosersItem>,
            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!(
                "{}/v2/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 `/v2/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!(
                "{}/v2/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 `/v2/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!(
                "{}/v2/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<types::SendChain, 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<types::SendChain>,
        {
            self.chain = value
                .try_into()
                .map_err(|_| "conversion to `SendChain` 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 `/v2/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!(
                "{}/v2/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 `/v2/wallet/{chain}/first-tx`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::WalletsMapResponse>, 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!(
                "{}/v2/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 `/v2/wallet/{chain}/net-worth-summary`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::WalletNetWorthSummaryResponse>, 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!(
                "{}/v2/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>,
        resolution: Result<Option<types::PnlResolution>, 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()),
                resolution: 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 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
        }
        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 `/v2/wallet/{chain}/pnl-by-wallet`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::PnlDetailsResult>, Error<()>> {
            let Self { client, chain, resolution, token_address, wallet_addresses } = self;
            let chain = chain.map_err(Error::InvalidRequest)?;
            let resolution = resolution.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!(
                "{}/v2/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(
                        "resolution",
                        &resolution,
                    ),
                )
                .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::PageDirection>, String>,
        limit: Result<Option<i64>, 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::PageDirection>,
        {
            self.direction = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `PageDirection` for direction 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 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 `/v2/wallet/{chain}/{walletAddress}/balance-updates`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::PageResponseBalanceUpdate>, 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!(
                "{}/v2/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 `/v2/wallet/{chain}/{walletAddress}/calculate-pnl`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::SuccessResponse>, 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!(
                "{}/v2/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::PageDirection>, String>,
        limit: Result<Option<i64>, 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::PageDirection>,
        {
            self.direction = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `PageDirection` for direction 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
        }
        ///Sends a `GET` request to `/v2/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!(
                "{}/v2/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<i32>, 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<i32>,
        {
            self.hours = value
                .try_into()
                .map(Some)
                .map_err(|_| "conversion to `i32` for hours failed".to_string());
            self
        }
        ///Sends a `GET` request to `/v2/wallet/{chain}/{walletAddress}/net-worth-chart`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::WalletNetWorthChartResponse>, 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!(
                "{}/v2/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::PageDirection>, String>,
        hours: Result<Option<i32>, String>,
        limit: Result<Option<i64>, 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::PageDirection>,
        {
            self.direction = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `PageDirection` 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<i64>,
        {
            self.limit = value
                .try_into()
                .map(Some)
                .map_err(|_| "conversion to `i64` for limit failed".to_string());
            self
        }
        ///Sends a `GET` request to `/v2/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!(
                "{}/v2/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_net_worth_by_tokens`]

[`Client::get_net_worth_by_tokens`]: super::Client::get_net_worth_by_tokens*/
    #[derive(Debug, Clone)]
    pub struct GetNetWorthByTokens<'a> {
        client: &'a super::Client,
        chain: Result<types::ChainSymbol, String>,
        wallet_address: Result<::std::string::String, String>,
        token_addresses: Result<::std::string::String, String>,
    }
    impl<'a> GetNetWorthByTokens<'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()),
                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 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 `/v2/wallet/{chain}/{walletAddress}/net-worth/tokens`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::NetWorthByTokensResult>, Error<()>> {
            let Self { client, chain, wallet_address, token_addresses } = self;
            let chain = chain.map_err(Error::InvalidRequest)?;
            let wallet_address = wallet_address.map_err(Error::InvalidRequest)?;
            let token_addresses = token_addresses.map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v2/wallet/{}/{}/net-worth/tokens", 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(
                        "tokenAddresses",
                        &token_addresses,
                    ),
                )
                .headers(header_map)
                .build()?;
            let info = OperationInfo {
                operation_id: "get_net_worth_by_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_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 `/v2/wallet/{chain}/{walletAddress}/pnl`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::WalletPnlSummary>, 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!(
                "{}/v2/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>,
        resolution: Result<Option<types::PnlResolution>, 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()),
                resolution: 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 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
        }
        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 `/v2/wallet/{chain}/{walletAddress}/pnl-by-token`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::PnlDetailsResult>, Error<()>> {
            let Self { client, chain, wallet_address, resolution, token_addresses } = 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 token_addresses = token_addresses.map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v2/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(
                        "resolution",
                        &resolution,
                    ),
                )
                .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::PageDirection>, String>,
        limit: Result<Option<i64>, String>,
        resolution: Result<types::PnlResolution, 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),
                resolution: Err("resolution 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::PageDirection>,
        {
            self.direction = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `PageDirection` for direction 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 resolution<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<types::PnlResolution>,
        {
            self.resolution = value
                .try_into()
                .map_err(|_| {
                    "conversion to `PnlResolution` for resolution failed".to_string()
                });
            self
        }
        ///Sends a `GET` request to `/v2/wallet/{chain}/{walletAddress}/pnl-details`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::PnlDetailsResult>, Error<()>> {
            let Self {
                client,
                chain,
                wallet_address,
                cursor,
                direction,
                limit,
                resolution,
            } = 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 resolution = resolution.map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v2/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))
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "resolution",
                        &resolution,
                    ),
                )
                .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::PageDirection>, String>,
        limit: Result<Option<i64>, 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::PageDirection>,
        {
            self.direction = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `PageDirection` for direction 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
        }
        ///Sends a `GET` request to `/v2/wallet/{chain}/{walletAddress}/tokens-balance`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::PageResponseNetWorthByTokensItem>, 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!(
                "{}/v2/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>,
        from_timestamp: Result<Option<i64>, 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>,
        to_timestamp: Result<Option<i64>, 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()),
                from_timestamp: 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),
                to_timestamp: 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 from_timestamp<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<i64>,
        {
            self.from_timestamp = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `i64` for from_timestamp 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 to_timestamp<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<i64>,
        {
            self.to_timestamp = value
                .try_into()
                .map(Some)
                .map_err(|_| "conversion to `i64` for to_timestamp 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 `/v2/wallet/{chain}/{walletAddress}/transfer-total`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::TransferTotalResponse>, Error<()>> {
            let Self {
                client,
                chain,
                wallet_address,
                from_timestamp,
                max_token_amount,
                max_token_amount_in_usd,
                min_token_amount,
                min_token_amount_in_usd,
                to_timestamp,
                token_address,
            } = self;
            let chain = chain.map_err(Error::InvalidRequest)?;
            let wallet_address = wallet_address.map_err(Error::InvalidRequest)?;
            let from_timestamp = from_timestamp.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 to_timestamp = to_timestamp.map_err(Error::InvalidRequest)?;
            let token_address = token_address.map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v2/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(
                        "fromTimestamp",
                        &from_timestamp,
                    ),
                )
                .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(
                        "toTimestamp",
                        &to_timestamp,
                    ),
                )
                .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>,
        cursor: Result<Option<::std::string::String>, String>,
        direction: Result<Option<types::PageDirection>, String>,
        from_timestamp: Result<Option<i64>, String>,
        limit: Result<Option<i64>, 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>,
        to_timestamp: Result<Option<i64>, 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()),
                cursor: Ok(None),
                direction: Ok(None),
                from_timestamp: 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),
                to_timestamp: 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 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::PageDirection>,
        {
            self.direction = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `PageDirection` for direction failed".to_string()
                });
            self
        }
        pub fn from_timestamp<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<i64>,
        {
            self.from_timestamp = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `i64` for from_timestamp 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 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 to_timestamp<V>(mut self, value: V) -> Self
        where
            V: std::convert::TryInto<i64>,
        {
            self.to_timestamp = value
                .try_into()
                .map(Some)
                .map_err(|_| "conversion to `i64` for to_timestamp 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 `/v2/wallet/{chain}/{walletAddress}/transfers`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::PageResponseWalletTransfer>, Error<()>> {
            let Self {
                client,
                chain,
                wallet_address,
                cursor,
                direction,
                from_timestamp,
                limit,
                max_token_amount,
                max_token_amount_in_usd,
                min_token_amount,
                min_token_amount_in_usd,
                to_timestamp,
                token_address,
            } = 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 from_timestamp = from_timestamp.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 to_timestamp = to_timestamp.map_err(Error::InvalidRequest)?;
            let token_address = token_address.map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v2/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("cursor", &cursor))
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "direction",
                        &direction,
                    ),
                )
                .query(
                    &progenitor_middleware_client::QueryParam::new(
                        "fromTimestamp",
                        &from_timestamp,
                    ),
                )
                .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(
                        "toTimestamp",
                        &to_timestamp,
                    ),
                )
                .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 `/v2/watchlist/{chain}/{walletAddress}`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::WatchlistAddResponseModel>, 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!(
                "{}/v2/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::EndpointOrder>, 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::EndpointOrder>,
        {
            self.order = value
                .try_into()
                .map(Some)
                .map_err(|_| {
                    "conversion to `EndpointOrder` for order failed".to_string()
                });
            self
        }
        ///Sends a `GET` request to `/v2/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!("{}/v2/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::CreateWebhookRequest, 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::CreateWebhookRequest>,
            <V as std::convert::TryInto<
                types::CreateWebhookRequest,
            >>::Error: std::fmt::Display,
        {
            self.body = value
                .try_into()
                .map(From::from)
                .map_err(|s| {
                    format!(
                        "conversion to `CreateWebhookRequest` for body failed: {}", s
                    )
                });
            self
        }
        pub fn body_map<F>(mut self, f: F) -> Self
        where
            F: std::ops::FnOnce(
                types::builder::CreateWebhookRequest,
            ) -> types::builder::CreateWebhookRequest,
        {
            self.body = self.body.map(f);
            self
        }
        ///Sends a `POST` request to `/v2/webhook/endpoint`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::WebhookEndpoint>, Error<()>> {
            let Self { client, body } = self;
            let body = body
                .and_then(|v| {
                    types::CreateWebhookRequest::try_from(v).map_err(|e| e.to_string())
                })
                .map_err(Error::InvalidRequest)?;
            let url = format!("{}/v2/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::UpdateWebhookRequest, 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::UpdateWebhookRequest>,
            <V as std::convert::TryInto<
                types::UpdateWebhookRequest,
            >>::Error: std::fmt::Display,
        {
            self.body = value
                .try_into()
                .map(From::from)
                .map_err(|s| {
                    format!(
                        "conversion to `UpdateWebhookRequest` for body failed: {}", s
                    )
                });
            self
        }
        pub fn body_map<F>(mut self, f: F) -> Self
        where
            F: std::ops::FnOnce(
                types::builder::UpdateWebhookRequest,
            ) -> types::builder::UpdateWebhookRequest,
        {
            self.body = self.body.map(f);
            self
        }
        ///Sends a `PATCH` request to `/v2/webhook/endpoint`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::WebhookEndpoint>, Error<()>> {
            let Self { client, body } = self;
            let body = body
                .and_then(|v| {
                    types::UpdateWebhookRequest::try_from(v).map_err(|e| e.to_string())
                })
                .map_err(Error::InvalidRequest)?;
            let url = format!("{}/v2/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 `/v2/webhook/endpoint/{id}`
        pub async fn send(
            self,
        ) -> Result<ResponseValue<types::WebhookEndpoint>, Error<()>> {
            let Self { client, id } = self;
            let id = id.map_err(Error::InvalidRequest)?;
            let url = format!(
                "{}/v2/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 `/v2/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!(
                "{}/v2/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 `/v2/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!(
                "{}/v2/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 `/v2/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!(
                "{}/v2/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;
}
