jupiter-api-rs 0.1.0

//! Generated types from OpenAPI specification
//!
//! This file contains all the generated types for the API.
//! Do not edit manually - regenerate using the appropriate script.
//! Generated by openapi-to-rust v0.12.2. Source OpenAPI document: openapi/jupiter.yaml
#![allow(clippy::large_enum_variant)]
#![allow(clippy::format_in_format_args)]
#![allow(clippy::let_unit_value)]
#![allow(unreachable_patterns)]
use serde::{Deserialize, Serialize};
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct UltraHoldingsResponse {
    ///Total SOL in lamports
    pub amount: String,
    ///Other token holdings organized by mint address as keys
    pub tokens: UltraHoldingsResponseTokens,
    ///Total SOL in UI units after applying decimals
    #[serde(rename = "uiAmount")]
    pub ui_amount: f64,
    ///Total SOL as string in UI units after applying decimals
    #[serde(rename = "uiAmountString")]
    pub ui_amount_string: String,
}
///Other token holdings organized by mint address as keys
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct UltraHoldingsResponseTokens {
    /// Additional properties matching the spec's
    /// `additionalProperties` value schema.
    #[serde(flatten)]
    pub additional_properties: std::collections::BTreeMap<String, Vec<UltraTokenAccount>>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct UltraTokenAccount {
    ///The token account address
    pub account: String,
    ///Token amount in atomic/raw units
    pub amount: String,
    ///Number of decimal places for the token
    pub decimals: f64,
    ///Whether this is an associated token account
    #[serde(rename = "isAssociatedTokenAccount")]
    pub is_associated_token_account: bool,
    ///Whether the token account is frozen
    #[serde(rename = "isFrozen")]
    pub is_frozen: bool,
    ///The token program ID
    #[serde(rename = "programId")]
    pub program_id: String,
    ///Token amount in UI units after applying decimals
    #[serde(rename = "uiAmount")]
    pub ui_amount: f64,
    ///Token amount as string in UI units after applying decimals
    #[serde(rename = "uiAmountString")]
    pub ui_amount_string: String,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct TriggerV2ErrorResponse {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub details: Option<TriggerV2ErrorResponseDetails>,
    pub error: String,
}
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct TriggerV2ErrorResponseDetails {
    /// Additional properties matching the spec's
    /// `additionalProperties` value schema.
    #[serde(flatten)]
    pub additional_properties: std::collections::BTreeMap<String, String>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct TokensV2VerificationExpressExecuteResponse {
    ///Error code (present on failure)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub code: Option<f64>,
    ///Error message (present on failure)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub error: Option<String>,
    ///Whether a metadata update request was created
    #[serde(rename = "metadataCreated")]
    pub metadata_created: bool,
    ///Transaction signature on-chain (present on success)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub signature: Option<String>,
    ///Whether the transaction was executed successfully
    pub status: TokensV2VerificationExpressExecuteResponseStatus,
    ///Time taken to execute in milliseconds
    #[serde(rename = "totalTime")]
    pub total_time: f64,
    ///Whether a verification request was created
    #[serde(rename = "verificationCreated")]
    pub verification_created: bool,
}
///Whether the transaction was executed successfully
#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize, Default)]
pub enum TokensV2VerificationExpressExecuteResponseStatus {
    #[default]
    #[serde(rename = "Success")]
    Success,
    #[serde(rename = "Failed")]
    Failed,
}
impl TokensV2VerificationExpressExecuteResponseStatus {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::Success => "Success",
            Self::Failed => "Failed",
        }
    }
}
impl ::std::fmt::Display for TokensV2VerificationExpressExecuteResponseStatus {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        f.write_str(self.as_str())
    }
}
impl AsRef<str> for TokensV2VerificationExpressExecuteResponseStatus {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct TokensV2VerificationExpressExecuteBody {
    ///Reason for verification request
    pub description: String,
    ///Atomic JUP output from the craft quote (CraftTxnResponse.amount), echoed back so revenue tracks the actual JUP collected on swap paths.
    #[serde(rename = "jupOutputAmount", skip_serializing_if = "Option::is_none")]
    pub jup_output_amount: Option<String>,
    ///Atomic input amount paid. Required when paymentCurrency is not JUP.
    #[serde(rename = "paymentAmount", skip_serializing_if = "Option::is_none")]
    pub payment_amount: Option<String>,
    #[serde(rename = "paymentCurrency", skip_serializing_if = "Option::is_none")]
    pub payment_currency: Option<TokensV2VerificationPaymentCurrency>,
    ///requestId returned by craft-txn
    #[serde(rename = "requestId")]
    pub request_id: String,
    ///Solana wallet address of the sender
    #[serde(rename = "senderAddress")]
    pub sender_address: String,
    ///Twitter/X handle of the submitter (optional)
    #[serde(
        rename = "senderTwitterHandle",
        skip_serializing_if = "Option::is_none"
    )]
    pub sender_twitter_handle: Option<String>,
    ///Token mint address to verify
    #[serde(rename = "tokenId")]
    pub token_id: String,
    #[serde(rename = "tokenMetadata", skip_serializing_if = "Option::is_none")]
    pub token_metadata: Option<TokensV2VerificationTokenMetadataInput>,
    ///Base64-encoded signed transaction from the craft-txn step
    pub transaction: String,
    ///Twitter/X handle of the token project
    #[serde(rename = "twitterHandle")]
    pub twitter_handle: String,
}
impl TokensV2VerificationExpressExecuteBody {
    /// Construct this request with every required wire field.
    pub fn new(
        description: String,
        request_id: String,
        sender_address: String,
        token_id: String,
        transaction: String,
        twitter_handle: String,
    ) -> Self {
        Self {
            description,
            request_id,
            sender_address,
            token_id,
            transaction,
            twitter_handle,
            jup_output_amount: None,
            payment_amount: None,
            payment_currency: None,
            sender_twitter_handle: None,
            token_metadata: None,
        }
    }
    /// Start a dependency-free builder with every required wire field.
    pub fn builder(
        description: String,
        request_id: String,
        sender_address: String,
        token_id: String,
        transaction: String,
        twitter_handle: String,
    ) -> TokensV2VerificationExpressExecuteBodyBuilder {
        TokensV2VerificationExpressExecuteBodyBuilder::new(
            description,
            request_id,
            sender_address,
            token_id,
            transaction,
            twitter_handle,
        )
    }
}
/// Dependency-free builder for [`#struct_name`].
#[derive(Debug, Clone)]
#[must_use]
pub struct TokensV2VerificationExpressExecuteBodyBuilder {
    value: TokensV2VerificationExpressExecuteBody,
}
impl TokensV2VerificationExpressExecuteBodyBuilder {
    /// Start a builder with every required wire field.
    pub fn new(
        description: String,
        request_id: String,
        sender_address: String,
        token_id: String,
        transaction: String,
        twitter_handle: String,
    ) -> Self {
        Self {
            value: TokensV2VerificationExpressExecuteBody::new(
                description,
                request_id,
                sender_address,
                token_id,
                transaction,
                twitter_handle,
            ),
        }
    }
    #[doc = concat!("Set the optional `", "jupOutputAmount", "` request field.")]
    #[must_use]
    pub fn jup_output_amount(mut self, jup_output_amount: String) -> Self {
        self.value.jup_output_amount = Some(jup_output_amount);
        self
    }
    #[doc = concat!("Set the optional `", "paymentAmount", "` request field.")]
    #[must_use]
    pub fn payment_amount(mut self, payment_amount: String) -> Self {
        self.value.payment_amount = Some(payment_amount);
        self
    }
    #[doc = concat!("Set the optional `", "paymentCurrency", "` request field.")]
    #[must_use]
    pub fn payment_currency(
        mut self,
        payment_currency: TokensV2VerificationPaymentCurrency,
    ) -> Self {
        self.value.payment_currency = Some(payment_currency);
        self
    }
    #[doc = concat!("Set the optional `", "senderTwitterHandle", "` request field.")]
    #[must_use]
    pub fn sender_twitter_handle(mut self, sender_twitter_handle: String) -> Self {
        self.value.sender_twitter_handle = Some(sender_twitter_handle);
        self
    }
    #[doc = concat!("Set the optional `", "tokenMetadata", "` request field.")]
    #[must_use]
    pub fn token_metadata(
        mut self,
        token_metadata: TokensV2VerificationTokenMetadataInput,
    ) -> Self {
        self.value.token_metadata = Some(token_metadata);
        self
    }
    /// Finish building the request model.
    pub fn build(self) -> TokensV2VerificationExpressExecuteBody {
        self.value
    }
}
///Optional token metadata to submit alongside verification
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct TokensV2VerificationTokenMetadataInput {
    ///Circulating supply value
    #[serde(rename = "circulatingSupply", skip_serializing_if = "Option::is_none")]
    pub circulating_supply: Option<String>,
    ///URL to a live circulating supply endpoint
    #[serde(
        rename = "circulatingSupplyUrl",
        skip_serializing_if = "Option::is_none"
    )]
    pub circulating_supply_url: Option<String>,
    ///CoinGecko coin ID for price data
    #[serde(rename = "coingeckoCoinId", skip_serializing_if = "Option::is_none")]
    pub coingecko_coin_id: Option<String>,
    ///Discord invite URL
    #[serde(skip_serializing_if = "Option::is_none")]
    pub discord: Option<String>,
    ///URL to token icon image
    #[serde(skip_serializing_if = "Option::is_none")]
    pub icon: Option<String>,
    ///Instagram profile URL
    #[serde(skip_serializing_if = "Option::is_none")]
    pub instagram: Option<String>,
    ///Token display name
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    ///Any other relevant URL
    #[serde(rename = "otherUrl", skip_serializing_if = "Option::is_none")]
    pub other_url: Option<String>,
    ///Token ticker symbol
    #[serde(skip_serializing_if = "Option::is_none")]
    pub symbol: Option<String>,
    ///Telegram group URL
    #[serde(skip_serializing_if = "Option::is_none")]
    pub telegram: Option<String>,
    ///TikTok profile URL
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tiktok: Option<String>,
    ///Short description of the token
    #[serde(rename = "tokenDescription", skip_serializing_if = "Option::is_none")]
    pub token_description: Option<String>,
    ///Token mint address
    #[serde(rename = "tokenId")]
    pub token_id: String,
    ///Twitter/X profile URL
    #[serde(skip_serializing_if = "Option::is_none")]
    pub twitter: Option<String>,
    ///Twitter/X community URL
    #[serde(rename = "twitterCommunity", skip_serializing_if = "Option::is_none")]
    pub twitter_community: Option<String>,
    ///Whether to use the provided circulating supply
    #[serde(
        rename = "useCirculatingSupply",
        skip_serializing_if = "Option::is_none"
    )]
    pub use_circulating_supply: Option<bool>,
    ///Whether to use the provided circulating supply URL
    #[serde(
        rename = "useCirculatingSupplyUrl",
        skip_serializing_if = "Option::is_none"
    )]
    pub use_circulating_supply_url: Option<bool>,
    ///Whether to use the provided CoinGecko ID
    #[serde(rename = "useCoingeckoCoinId", skip_serializing_if = "Option::is_none")]
    pub use_coingecko_coin_id: Option<bool>,
    ///Project website URL
    #[serde(skip_serializing_if = "Option::is_none")]
    pub website: Option<String>,
}
/**Accepted payment currency, given as a token symbol (not a mint address): JUP, SOL, USDC, or JUPUSD.
All input currencies are converted to 1000 JUP. JUP transfers directly; SOL, USDC, and JUPUSD are
swapped to 1000 JUP via Ultra.
*/
#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize, Default)]
pub enum TokensV2VerificationPaymentCurrency {
    #[default]
    #[serde(rename = "JUP")]
    Jup,
    #[serde(rename = "SOL")]
    Sol,
    #[serde(rename = "USDC")]
    Usdc,
    #[serde(rename = "JUPUSD")]
    Jupusd,
}
impl TokensV2VerificationPaymentCurrency {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::Jup => "JUP",
            Self::Sol => "SOL",
            Self::Usdc => "USDC",
            Self::Jupusd => "JUPUSD",
        }
    }
}
impl ::std::fmt::Display for TokensV2VerificationPaymentCurrency {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        f.write_str(self.as_str())
    }
}
impl AsRef<str> for TokensV2VerificationPaymentCurrency {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct SwapV1SwapRequest {
    /**- Builds a legacy transaction rather than the default versioned transaction
    - Used together with `asLegacyTransaction` in `/quote`, otherwise the transaction might be too large
    */
    #[serde(
        rename = "asLegacyTransaction",
        skip_serializing_if = "Option::is_none"
    )]
    pub as_legacy_transaction: Option<bool>,
    /**- Pass in the number of slots we want the transaction to be valid for
    - Example: If you pass in 10 slots, the transaction will be valid for ~400ms * 10 = approximately 4 seconds before it expires
    */
    #[serde(
        rename = "blockhashSlotsToExpiry",
        skip_serializing_if = "Option::is_none"
    )]
    pub blockhash_slots_to_expiry: Option<i64>,
    /**- To use an exact compute unit price to calculate priority fee
    - `computeUnitLimit (1400000) * computeUnitPriceMicroLamports`
    - We recommend using `prioritizationFeeLamports` and `dynamicComputeUnitLimit` instead of passing in your own compute unit price
    */
    #[serde(
        rename = "computeUnitPriceMicroLamports",
        skip_serializing_if = "Option::is_none"
    )]
    pub compute_unit_price_micro_lamports: Option<u64>,
    /**- Public key of a token account that will be used to receive the token out of the swap
    - If not provided, the signer's token account will be used
    - If provided, we assume that the token account is already initialized
    - `destinationTokenAccount` and `nativeDestinationAccount` are mutually exclusive
    */
    #[serde(
        rename = "destinationTokenAccount",
        skip_serializing_if = "Option::is_none"
    )]
    pub destination_token_account: Option<String>,
    /**- When enabled, simulates the swap to provide an accurate compute unit limit in the transaction
    - This incurs one extra RPC call to simulate
    - Recommended for all normal flows — reduces priority fees needed and improves transaction landing
    */
    #[serde(
        rename = "dynamicComputeUnitLimit",
        skip_serializing_if = "Option::is_none"
    )]
    pub dynamic_compute_unit_limit: Option<bool>,
    /**- When enabled, it estimates slippage and apply it in the swap transaction directly, overwriting the `slippageBps` parameter in the quote response.
    - This is no longer maintained, we are focusing efforts on RTSE on Ultra Swap API
    */
    #[serde(rename = "dynamicSlippage", skip_serializing_if = "Option::is_none")]
    pub dynamic_slippage: Option<bool>,
    /**- An initialized token account that will be used to collect fees
    - The mint of the token account **can only be either the input or output mint of the swap**
    - Swap API no longer requires the use of the Referral Program
    - If `platformFeeBps` is passed in `/quote`, the `feeAccount` must be passed as well
    */
    #[serde(rename = "feeAccount", skip_serializing_if = "Option::is_none")]
    pub fee_account: Option<String>,
    /**- Public key of an account that will be used to receive the native SOL token out of the swap
    - If not provided, the swap will default unwrap the WSOL and transfer the native SOL to the swap authority account
    - If provided, we will unwrap the WSOL and transfer the native SOL to the account
    - Only works if the output mint is SOL, is using the V2 instructions and the account passed in is not owned by token program
    - When sending native SOL to a new account, you must swap at least enough to cover the rent required to create it.
    - `destinationTokenAccount` and `nativeDestinationAccount` are mutually exclusive
    */
    #[serde(
        rename = "nativeDestinationAccount",
        skip_serializing_if = "Option::is_none"
    )]
    pub native_destination_account: Option<String>,
    /**- Allow a custom payer to pay for the transaction fees and rent of token accounts
    - Note that users can close their ATAs elsewhere and have you reopen them again, your fees should account for this
    */
    #[serde(skip_serializing_if = "Option::is_none")]
    pub payer: Option<String>,
    /**- To specify a level or amount of additional fees to prioritize the transaction
    - It can be used for EITHER priority fee OR Jito tip (not both at the same time)
    - If you want to include both, you will need to use `/swap-instructions` to add both at the same time
    - Defaults to `auto`, but preferred to use `priorityLevelWithMaxLamports` as it may be more accurate when accounting local fee market
    - Fixed lamports can be passed in as an integer in the `prioritizationFeeLamports` parameter
    */
    #[serde(
        rename = "prioritizationFeeLamports",
        skip_serializing_if = "Option::is_none"
    )]
    pub prioritization_fee_lamports: Option<SwapV1SwapRequestPrioritizationFeeLamports>,
    #[serde(rename = "quoteResponse")]
    pub quote_response: SwapV1QuoteResponse,
    /**- When enabled, it will not do any additional RPC calls to check on required accounts
    - The returned swap transaction will still attempt to create required accounts regardless if it exists or not
    */
    #[serde(
        rename = "skipUserAccountsRpcCalls",
        skip_serializing_if = "Option::is_none"
    )]
    pub skip_user_accounts_rpc_calls: Option<bool>,
    /**- Specify any public key that belongs to you to track the transactions
    - Useful for integrators to get all the swap transactions from this public key
    - Query the data using a block explorer like Solscan/SolanaFM or query like Dune/Flipside
    */
    #[serde(rename = "trackingAccount", skip_serializing_if = "Option::is_none")]
    pub tracking_account: Option<String>,
    /**- The default is determined dynamically by the routing engine, allowing us to optimize for compute units, etc
    - This enables the usage of shared program accounts, this is essential as complex routing will require multiple intermediate token accounts which the user might not have
    - If true, you do not need to handle the creation of intermediate token accounts for the user
    - Do note, shared accounts route will fail on some new AMMs (low liquidity token)
    */
    #[serde(rename = "useSharedAccounts", skip_serializing_if = "Option::is_none")]
    pub use_shared_accounts: Option<bool>,
    #[serde(rename = "userPublicKey")]
    pub user_public_key: String,
    /**- To automatically wrap/unwrap SOL in the transaction, as WSOL is an SPL token while native SOL is not
    - When true and input mint is SOL, it will wrap the SOL amount to WSOL and swap
    - When true and output mint is SOL, it will unwrap the WSOL back to SOL
    - When true, the wSOL token account is always closed after the transaction, regardless of whether SOL is the input or output mint
    - When false and input mint is SOL, it will use existing WSOL amount to swap
    - When false and output mint is SOL, it will not unwrap the WSOL to SOL
    - To set this parameter to false, you need to have the WSOL token account initialized
    */
    #[serde(rename = "wrapAndUnwrapSol", skip_serializing_if = "Option::is_none")]
    pub wrap_and_unwrap_sol: Option<bool>,
}
impl SwapV1SwapRequest {
    /// Construct this request with every required wire field.
    pub fn new(quote_response: SwapV1QuoteResponse, user_public_key: String) -> Self {
        Self {
            quote_response,
            user_public_key,
            as_legacy_transaction: None,
            blockhash_slots_to_expiry: None,
            compute_unit_price_micro_lamports: None,
            destination_token_account: None,
            dynamic_compute_unit_limit: None,
            dynamic_slippage: None,
            fee_account: None,
            native_destination_account: None,
            payer: None,
            prioritization_fee_lamports: None,
            skip_user_accounts_rpc_calls: None,
            tracking_account: None,
            use_shared_accounts: None,
            wrap_and_unwrap_sol: None,
        }
    }
    /// Start a dependency-free builder with every required wire field.
    pub fn builder(
        quote_response: SwapV1QuoteResponse,
        user_public_key: String,
    ) -> SwapV1SwapRequestBuilder {
        SwapV1SwapRequestBuilder::new(quote_response, user_public_key)
    }
}
/// Dependency-free builder for [`#struct_name`].
#[derive(Debug, Clone)]
#[must_use]
pub struct SwapV1SwapRequestBuilder {
    value: SwapV1SwapRequest,
}
impl SwapV1SwapRequestBuilder {
    /// Start a builder with every required wire field.
    pub fn new(quote_response: SwapV1QuoteResponse, user_public_key: String) -> Self {
        Self {
            value: SwapV1SwapRequest::new(quote_response, user_public_key),
        }
    }
    #[doc = concat!("Set the optional `", "asLegacyTransaction", "` request field.")]
    #[must_use]
    pub fn as_legacy_transaction(mut self, as_legacy_transaction: bool) -> Self {
        self.value.as_legacy_transaction = Some(as_legacy_transaction);
        self
    }
    #[doc = concat!("Set the optional `", "blockhashSlotsToExpiry", "` request field.")]
    #[must_use]
    pub fn blockhash_slots_to_expiry(mut self, blockhash_slots_to_expiry: i64) -> Self {
        self.value.blockhash_slots_to_expiry = Some(blockhash_slots_to_expiry);
        self
    }
    #[doc = concat!(
        "Set the optional `", "computeUnitPriceMicroLamports", "` request field."
    )]
    #[must_use]
    pub fn compute_unit_price_micro_lamports(
        mut self,
        compute_unit_price_micro_lamports: u64,
    ) -> Self {
        self.value.compute_unit_price_micro_lamports = Some(compute_unit_price_micro_lamports);
        self
    }
    #[doc = concat!("Set the optional `", "destinationTokenAccount", "` request field.")]
    #[must_use]
    pub fn destination_token_account(mut self, destination_token_account: String) -> Self {
        self.value.destination_token_account = Some(destination_token_account);
        self
    }
    #[doc = concat!("Set the optional `", "dynamicComputeUnitLimit", "` request field.")]
    #[must_use]
    pub fn dynamic_compute_unit_limit(mut self, dynamic_compute_unit_limit: bool) -> Self {
        self.value.dynamic_compute_unit_limit = Some(dynamic_compute_unit_limit);
        self
    }
    #[doc = concat!("Set the optional `", "dynamicSlippage", "` request field.")]
    #[must_use]
    pub fn dynamic_slippage(mut self, dynamic_slippage: bool) -> Self {
        self.value.dynamic_slippage = Some(dynamic_slippage);
        self
    }
    #[doc = concat!("Set the optional `", "feeAccount", "` request field.")]
    #[must_use]
    pub fn fee_account(mut self, fee_account: String) -> Self {
        self.value.fee_account = Some(fee_account);
        self
    }
    #[doc = concat!(
        "Set the optional `", "nativeDestinationAccount", "` request field."
    )]
    #[must_use]
    pub fn native_destination_account(mut self, native_destination_account: String) -> Self {
        self.value.native_destination_account = Some(native_destination_account);
        self
    }
    #[doc = concat!("Set the optional `", "payer", "` request field.")]
    #[must_use]
    pub fn payer(mut self, payer: String) -> Self {
        self.value.payer = Some(payer);
        self
    }
    #[doc = concat!(
        "Set the optional `", "prioritizationFeeLamports", "` request field."
    )]
    #[must_use]
    pub fn prioritization_fee_lamports(
        mut self,
        prioritization_fee_lamports: SwapV1SwapRequestPrioritizationFeeLamports,
    ) -> Self {
        self.value.prioritization_fee_lamports = Some(prioritization_fee_lamports);
        self
    }
    #[doc = concat!(
        "Set the optional `", "skipUserAccountsRpcCalls", "` request field."
    )]
    #[must_use]
    pub fn skip_user_accounts_rpc_calls(mut self, skip_user_accounts_rpc_calls: bool) -> Self {
        self.value.skip_user_accounts_rpc_calls = Some(skip_user_accounts_rpc_calls);
        self
    }
    #[doc = concat!("Set the optional `", "trackingAccount", "` request field.")]
    #[must_use]
    pub fn tracking_account(mut self, tracking_account: String) -> Self {
        self.value.tracking_account = Some(tracking_account);
        self
    }
    #[doc = concat!("Set the optional `", "useSharedAccounts", "` request field.")]
    #[must_use]
    pub fn use_shared_accounts(mut self, use_shared_accounts: bool) -> Self {
        self.value.use_shared_accounts = Some(use_shared_accounts);
        self
    }
    #[doc = concat!("Set the optional `", "wrapAndUnwrapSol", "` request field.")]
    #[must_use]
    pub fn wrap_and_unwrap_sol(mut self, wrap_and_unwrap_sol: bool) -> Self {
        self.value.wrap_and_unwrap_sol = Some(wrap_and_unwrap_sol);
        self
    }
    /// Finish building the request model.
    pub fn build(self) -> SwapV1SwapRequest {
        self.value
    }
}
/**- To specify a level or amount of additional fees to prioritize the transaction
- It can be used for EITHER priority fee OR Jito tip (not both at the same time)
- If you want to include both, you will need to use `/swap-instructions` to add both at the same time
- Defaults to `auto`, but preferred to use `priorityLevelWithMaxLamports` as it may be more accurate when accounting local fee market
- Fixed lamports can be passed in as an integer in the `prioritizationFeeLamports` parameter
*/
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
pub enum SwapV1SwapRequestPrioritizationFeeLamports {
    SwapV1PriorityLevelWithMaxLamports(SwapV1PriorityLevelWithMaxLamports),
    SwapV1JitoTipLamports(SwapV1JitoTipLamports),
    SwapV1JitoTipLamportsWithPayer(SwapV1JitoTipLamportsWithPayer),
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct SwapV1JitoTipLamports {
    /**- Exact amount of tip to use in a tip instruction
    - Refer to Jito docs on how to estimate the tip amount based on percentiles
    - It has to be used together with a connection to a Jito RPC
    - See their docs at https://docs.jito.wtf/
    */
    #[serde(rename = "jitoTipLamports")]
    pub jito_tip_lamports: u64,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct SwapV1SwapInstructionsResponse {
    /**- The lookup table addresses if you are using versioned transaction.
     */
    #[serde(rename = "addressLookupTableAddresses")]
    pub address_lookup_table_addresses: Vec<String>,
    #[serde(rename = "cleanupInstruction", skip_serializing_if = "Option::is_none")]
    pub cleanup_instruction: Option<SwapV1Instruction>,
    /**- To setup the compute budget for the transaction.
     */
    #[serde(rename = "computeBudgetInstructions")]
    pub compute_budget_instructions: Vec<SwapV1Instruction>,
    /**- If you set jito tips using the `prioritizationFeeLamports` parameter, you will see a custom tip instruction to Jito here.
     */
    #[serde(rename = "otherInstructions")]
    pub other_instructions: Vec<SwapV1Instruction>,
    /**- To setup required token accounts for the users.
     */
    #[serde(rename = "setupInstructions")]
    pub setup_instructions: Vec<SwapV1Instruction>,
    #[serde(rename = "swapInstruction")]
    pub swap_instruction: SwapV1Instruction,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct SwapV1QuoteResponse {
    #[serde(rename = "contextSlot", skip_serializing_if = "Option::is_none")]
    pub context_slot: Option<u64>,
    #[serde(rename = "inAmount")]
    pub in_amount: String,
    #[serde(rename = "inputMint")]
    pub input_mint: String,
    /**- Markets that would have quoted for this pair
    - Useful for debugging and verifying route decisions
    - Each key is an AMM account address, each value is the quoted output amount
    */
    #[serde(
        rename = "mostReliableAmmsQuoteReport",
        skip_serializing_if = "Option::is_none"
    )]
    pub most_reliable_amms_quote_report: Option<SwapV1QuoteResponseMostReliableAmmsQuoteReport>,
    /**- Minimum acceptable output amount — `outAmount` after applying `slippageBps` tolerance
    - Not used by `/swap` endpoint to build transaction
    */
    #[serde(rename = "otherAmountThreshold")]
    pub other_amount_threshold: String,
    /**- Best output amount after deducting AMM fees and platform fees
    - Does not account for slippage
    */
    #[serde(rename = "outAmount")]
    pub out_amount: String,
    #[serde(rename = "outputMint")]
    pub output_mint: String,
    #[serde(rename = "platformFee", skip_serializing_if = "Option::is_none")]
    pub platform_fee: Option<SwapV1PlatformFee>,
    #[serde(rename = "priceImpactPct")]
    pub price_impact_pct: String,
    #[serde(rename = "routePlan")]
    pub route_plan: Vec<SwapV1RoutePlanStep>,
    ///Constraint: minimum=0
    #[serde(rename = "slippageBps")]
    pub slippage_bps: i64,
    #[serde(rename = "swapMode")]
    pub swap_mode: SwapV1SwapMode,
    #[serde(rename = "timeTaken", skip_serializing_if = "Option::is_none")]
    pub time_taken: Option<f64>,
}
#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize, Default)]
pub enum SwapV1SwapMode {
    #[default]
    #[serde(rename = "ExactIn")]
    ExactIn,
    #[serde(rename = "ExactOut")]
    ExactOut,
}
impl SwapV1SwapMode {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::ExactIn => "ExactIn",
            Self::ExactOut => "ExactOut",
        }
    }
}
impl ::std::fmt::Display for SwapV1SwapMode {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        f.write_str(self.as_str())
    }
}
impl AsRef<str> for SwapV1SwapMode {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct SwapV1RoutePlanStep {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub bps: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub percent: Option<i64>,
    #[serde(rename = "swapInfo")]
    pub swap_info: SwapV1SwapInfo,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct SwapV1SwapInfo {
    #[serde(rename = "ammKey")]
    pub amm_key: String,
    #[serde(rename = "feeAmount", skip_serializing_if = "Option::is_none")]
    pub fee_amount: Option<String>,
    #[serde(rename = "feeMint", skip_serializing_if = "Option::is_none")]
    pub fee_mint: Option<String>,
    #[serde(rename = "inAmount")]
    pub in_amount: String,
    #[serde(rename = "inputMint")]
    pub input_mint: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub label: Option<String>,
    #[serde(rename = "outAmount")]
    pub out_amount: String,
    #[serde(rename = "outputMint")]
    pub output_mint: String,
}
/**- Markets that would have quoted for this pair
- Useful for debugging and verifying route decisions
- Each key is an AMM account address, each value is the quoted output amount
*/
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct SwapV1QuoteResponseMostReliableAmmsQuoteReport {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub info: Option<SwapV1QuoteResponseInfo>,
}
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct SwapV1QuoteResponseInfo {
    /// Additional properties matching the spec's
    /// `additionalProperties` value schema.
    #[serde(flatten)]
    pub additional_properties: std::collections::BTreeMap<String, String>,
}
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct SwapV1PlatformFee {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub amount: Option<String>,
    #[serde(rename = "feeBps", skip_serializing_if = "Option::is_none")]
    pub fee_bps: Option<i64>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct SwapV1PriorityLevelWithMaxLamports {
    #[serde(rename = "priorityLevelWithMaxLamports")]
    pub priority_level_with_max_lamports:
        SwapV1PriorityLevelWithMaxLamportsPriorityLevelWithMaxLamports,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct SwapV1PriorityLevelWithMaxLamportsPriorityLevelWithMaxLamports {
    /**- A boolean to choose between using a global or local fee market to estimate. If `global` is set to `false`, the estimation focuses on fees relevant to the **writable accounts** involved in the instruction.
     */
    #[serde(skip_serializing_if = "Option::is_none")]
    pub global: Option<bool>,
    /**- Maximum lamports to cap the priority fee estimation, to prevent overpaying
     */
    #[serde(rename = "maxLamports")]
    pub max_lamports: u64,
    #[serde(rename = "priorityLevel")]
    pub priority_level: SwapV1PriorityLevelWithMaxLamportsPriorityLevel,
}
#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize, Default)]
pub enum SwapV1PriorityLevelWithMaxLamportsPriorityLevel {
    #[default]
    #[serde(rename = "medium")]
    Medium,
    #[serde(rename = "high")]
    High,
    #[serde(rename = "veryHigh")]
    VeryHigh,
}
impl SwapV1PriorityLevelWithMaxLamportsPriorityLevel {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::Medium => "medium",
            Self::High => "high",
            Self::VeryHigh => "veryHigh",
        }
    }
}
impl ::std::fmt::Display for SwapV1PriorityLevelWithMaxLamportsPriorityLevel {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        f.write_str(self.as_str())
    }
}
impl AsRef<str> for SwapV1PriorityLevelWithMaxLamportsPriorityLevel {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct SwapV1JitoTipLamportsWithPayer {
    #[serde(rename = "jitoTipLamportsWithPayer")]
    pub jito_tip_lamports_with_payer: SwapV1JitoTipLamportsWithPayerJitoTipLamportsWithPayer,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct SwapV1JitoTipLamportsWithPayerJitoTipLamportsWithPayer {
    ///Exact amount of lamports to use for the tip
    pub lamports: u64,
    ///Public key of an account that will be used to pay for the tip
    pub payer: String,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct SwapV1Instruction {
    pub accounts: Vec<SwapV1AccountMeta>,
    pub data: String,
    #[serde(rename = "programId")]
    pub program_id: String,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct SwapV1AccountMeta {
    #[serde(rename = "isSigner")]
    pub is_signer: bool,
    #[serde(rename = "isWritable")]
    pub is_writable: bool,
    pub pubkey: String,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct SwapV1IndexedRouteMapResponse {
    ///All the possible route and their corresponding output mints
    #[serde(rename = "indexedRouteMap")]
    pub indexed_route_map: SwapV1IndexedRouteMapResponseIndexedRouteMap,
    ///All the mints that are indexed to match in indexedRouteMap
    #[serde(rename = "mintKeys")]
    pub mint_keys: Vec<String>,
}
///All the possible route and their corresponding output mints
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct SwapV1IndexedRouteMapResponseIndexedRouteMap {
    /// Additional properties matching the spec's
    /// `additionalProperties` value schema.
    #[serde(flatten)]
    pub additional_properties: std::collections::BTreeMap<String, Vec<f64>>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct StudioCreateDBCTransactionRequestBody {
    /**- Enable anti-sniping protection
    - Apply an additional swap fee immediately after launch to discourage bots
    - Starts at 99% and decreases 1% linearly over a randomized period
    */
    #[serde(rename = "antiSniping")]
    pub anti_sniping: bool,
    #[serde(rename = "buildCurveByMarketCapParam")]
    pub build_curve_by_market_cap_param:
        StudioCreateDBCTransactionRequestBodyBuildCurveByMarketCapParam,
    /**- Creator wallet public key
     */
    pub creator: String,
    /**- Fee configuration parameters
    - If not provided, the default fee will be 100 basis points (1%)
    */
    pub fee: StudioCreateDBCTransactionRequestBodyFee,
    /**- Whether LP tokens should be locked
    - If enabled, 50% of graduated LP unlocks after 1 year
    - Useful for creators to strategize in the long term
    */
    #[serde(rename = "isLpLocked", skip_serializing_if = "Option::is_none")]
    pub is_lp_locked: Option<bool>,
    /**- Token image content type
     */
    #[serde(rename = "tokenImageContentType")]
    pub token_image_content_type: StudioCreateDBCTransactionRequestBodyTokenImageContentType,
    ///Constraint: minLength=1
    #[serde(rename = "tokenName")]
    pub token_name: String,
    ///Constraint: minLength=1
    #[serde(rename = "tokenSymbol")]
    pub token_symbol: String,
}
impl StudioCreateDBCTransactionRequestBody {
    /// Construct this request with every required wire field.
    pub fn new(
        anti_sniping: bool,
        build_curve_by_market_cap_param: StudioCreateDBCTransactionRequestBodyBuildCurveByMarketCapParam,
        creator: String,
        fee: StudioCreateDBCTransactionRequestBodyFee,
        token_image_content_type: StudioCreateDBCTransactionRequestBodyTokenImageContentType,
        token_name: String,
        token_symbol: String,
    ) -> Self {
        Self {
            anti_sniping,
            build_curve_by_market_cap_param,
            creator,
            fee,
            token_image_content_type,
            token_name,
            token_symbol,
            is_lp_locked: None,
        }
    }
    /// Start a dependency-free builder with every required wire field.
    pub fn builder(
        anti_sniping: bool,
        build_curve_by_market_cap_param: StudioCreateDBCTransactionRequestBodyBuildCurveByMarketCapParam,
        creator: String,
        fee: StudioCreateDBCTransactionRequestBodyFee,
        token_image_content_type: StudioCreateDBCTransactionRequestBodyTokenImageContentType,
        token_name: String,
        token_symbol: String,
    ) -> StudioCreateDBCTransactionRequestBodyBuilder {
        StudioCreateDBCTransactionRequestBodyBuilder::new(
            anti_sniping,
            build_curve_by_market_cap_param,
            creator,
            fee,
            token_image_content_type,
            token_name,
            token_symbol,
        )
    }
}
/// Dependency-free builder for [`#struct_name`].
#[derive(Debug, Clone)]
#[must_use]
pub struct StudioCreateDBCTransactionRequestBodyBuilder {
    value: StudioCreateDBCTransactionRequestBody,
}
impl StudioCreateDBCTransactionRequestBodyBuilder {
    /// Start a builder with every required wire field.
    pub fn new(
        anti_sniping: bool,
        build_curve_by_market_cap_param: StudioCreateDBCTransactionRequestBodyBuildCurveByMarketCapParam,
        creator: String,
        fee: StudioCreateDBCTransactionRequestBodyFee,
        token_image_content_type: StudioCreateDBCTransactionRequestBodyTokenImageContentType,
        token_name: String,
        token_symbol: String,
    ) -> Self {
        Self {
            value: StudioCreateDBCTransactionRequestBody::new(
                anti_sniping,
                build_curve_by_market_cap_param,
                creator,
                fee,
                token_image_content_type,
                token_name,
                token_symbol,
            ),
        }
    }
    #[doc = concat!("Set the optional `", "isLpLocked", "` request field.")]
    #[must_use]
    pub fn is_lp_locked(mut self, is_lp_locked: bool) -> Self {
        self.value.is_lp_locked = Some(is_lp_locked);
        self
    }
    /// Finish building the request model.
    pub fn build(self) -> StudioCreateDBCTransactionRequestBody {
        self.value
    }
}
/**- Token image content type
*/
#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize, Default)]
pub enum StudioCreateDBCTransactionRequestBodyTokenImageContentType {
    #[default]
    #[serde(rename = "image/jpeg")]
    ImageJpeg,
    #[serde(rename = "image/png")]
    ImagePng,
    #[serde(rename = "image/gif")]
    ImageGif,
    #[serde(rename = "image/webp")]
    ImageWebp,
}
impl StudioCreateDBCTransactionRequestBodyTokenImageContentType {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::ImageJpeg => "image/jpeg",
            Self::ImagePng => "image/png",
            Self::ImageGif => "image/gif",
            Self::ImageWebp => "image/webp",
        }
    }
}
impl ::std::fmt::Display for StudioCreateDBCTransactionRequestBodyTokenImageContentType {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        f.write_str(self.as_str())
    }
}
impl AsRef<str> for StudioCreateDBCTransactionRequestBodyTokenImageContentType {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}
/**- Fee configuration parameters
- If not provided, the default fee will be 100 basis points (1%)
*/
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct StudioCreateDBCTransactionRequestBodyFee {
    ///Base fee mode for fee scheduler
    #[serde(rename = "baseFeeMode", skip_serializing_if = "Option::is_none")]
    pub base_fee_mode: Option<StudioCreateDBCTransactionRequestBodyBaseFeeMode>,
    ///Ending fee in basis points (100 or 200)
    #[serde(rename = "feeBps", default)]
    pub fee_bps: f64,
    ///Total duration for fee schedule
    #[serde(rename = "totalDuration", skip_serializing_if = "Option::is_none")]
    pub total_duration: Option<f64>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct StudioCreateDBCTransactionRequestBodyBuildCurveByMarketCapParam {
    /**- Initial market cap in quote token units
    - 16000 passed in = 16000 USDC/SOL/JUP initial market cap
    */
    #[serde(rename = "initialMarketCap")]
    pub initial_market_cap: f64,
    #[serde(rename = "lockedVestingParam")]
    pub locked_vesting_param: StudioCreateDBCTransactionRequestBodyLockedVestingParam,
    /**- Migration market cap in quote token units
    - 69000 passed in = 69000 USDC/SOL/JUP migration market cap
    */
    #[serde(rename = "migrationMarketCap")]
    pub migration_market_cap: f64,
    /**- Quote mint address
    - Either USDC, SOL, or JUP
    */
    #[serde(rename = "quoteMint")]
    pub quote_mint: String,
    /**- Token quote decimal places
     */
    #[serde(rename = "tokenQuoteDecimal")]
    pub token_quote_decimal: f64,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct StudioCreateDBCTransactionRequestBodyLockedVestingParam {
    /**- Cliff duration from migration time in seconds
     */
    #[serde(rename = "cliffDurationFromMigrationTime")]
    pub cliff_duration_from_migration_time: f64,
    /**- Amount of tokens unlocked at cliff
     */
    #[serde(rename = "cliffUnlockAmount")]
    pub cliff_unlock_amount: f64,
    /**- Number of vesting periods in days (183/365) or months (6/12)
     */
    #[serde(rename = "numberOfVestingPeriod")]
    pub number_of_vesting_period: f64,
    /**- Total locked vesting amount of tokens (0% to 80% of total supply)
     */
    #[serde(rename = "totalLockedVestingAmount")]
    pub total_locked_vesting_amount: f64,
    /**- Total vesting duration in seconds
     */
    #[serde(rename = "totalVestingDuration")]
    pub total_vesting_duration: f64,
}
///Base fee mode for fee scheduler
#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize, Default)]
pub enum StudioCreateDBCTransactionRequestBodyBaseFeeMode {
    #[default]
    #[serde(rename = "linear")]
    Linear,
    #[serde(rename = "exponential")]
    Exponential,
}
impl StudioCreateDBCTransactionRequestBodyBaseFeeMode {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::Linear => "linear",
            Self::Exponential => "exponential",
        }
    }
}
impl ::std::fmt::Display for StudioCreateDBCTransactionRequestBodyBaseFeeMode {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        f.write_str(self.as_str())
    }
}
impl AsRef<str> for StudioCreateDBCTransactionRequestBodyBaseFeeMode {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct SendInviteDataResponse {
    #[serde(rename = "hasMoreData")]
    pub has_more_data: bool,
    pub invites: Vec<SendInviteDataResponseInvitesItem>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct SendInviteDataResponseInvitesItem {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub action: Option<String>,
    pub amount: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub confirmed: Option<i64>,
    pub creation_time: String,
    pub creation_tx: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub deletion_time: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub deletion_tx: Option<String>,
    pub expiry: String,
    pub invite_pda: String,
    pub invite_signer: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub mint: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub receiver: Option<String>,
    pub sender: String,
}
///DEPRECATED: Price-based recurring orders are deprecated
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct RecurringWithdrawPriceRecurring {
    ///If no `amount` is provided, it will withdraw the entire amount
    ///Constraint: minimum=0
    #[serde(skip_serializing_if = "Option::is_none")]
    pub amount: Option<String>,
    #[serde(rename = "inputOrOutput")]
    pub input_or_output: RecurringWithdrawal,
    ///Base-58 account which is the Recurring Order account
    pub order: String,
    pub user: String,
}
impl RecurringWithdrawPriceRecurring {
    /// Construct this request with every required wire field.
    pub fn new(input_or_output: RecurringWithdrawal, order: String, user: String) -> Self {
        Self {
            input_or_output,
            order,
            user,
            amount: None,
        }
    }
    /// Start a dependency-free builder with every required wire field.
    pub fn builder(
        input_or_output: RecurringWithdrawal,
        order: String,
        user: String,
    ) -> RecurringWithdrawPriceRecurringBuilder {
        RecurringWithdrawPriceRecurringBuilder::new(input_or_output, order, user)
    }
}
/// Dependency-free builder for [`#struct_name`].
#[derive(Debug, Clone)]
#[must_use]
pub struct RecurringWithdrawPriceRecurringBuilder {
    value: RecurringWithdrawPriceRecurring,
}
impl RecurringWithdrawPriceRecurringBuilder {
    /// Start a builder with every required wire field.
    pub fn new(input_or_output: RecurringWithdrawal, order: String, user: String) -> Self {
        Self {
            value: RecurringWithdrawPriceRecurring::new(input_or_output, order, user),
        }
    }
    #[doc = concat!("Set the optional `", "amount", "` request field.")]
    #[must_use]
    pub fn amount(mut self, amount: String) -> Self {
        self.value.amount = Some(amount);
        self
    }
    /// Finish building the request model.
    pub fn build(self) -> RecurringWithdrawPriceRecurring {
        self.value
    }
}
#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize, Default)]
pub enum RecurringWithdrawal {
    #[default]
    #[serde(rename = "In")]
    In,
    #[serde(rename = "Out")]
    Out,
}
impl RecurringWithdrawal {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::In => "In",
            Self::Out => "Out",
        }
    }
}
impl ::std::fmt::Display for RecurringWithdrawal {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        f.write_str(self.as_str())
    }
}
impl AsRef<str> for RecurringWithdrawal {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}
///DEPRECATED: Price-based recurring orders are deprecated
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct RecurringRecurringTypeVariant2 {
    pub price: RecurringOpenIxArgsWithoutIdx,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct RecurringRecurringTypeVariant {
    pub time: RecurringTimeRecurringCreationParams,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct RecurringGetRecurringOrderResponseVariant3 {
    pub all: Vec<RecurringAllRecurringResponse>,
    #[serde(rename = "orderStatus")]
    pub order_status: RecurringOrderState,
    ///Constraint: minimum=1
    pub page: i64,
    ///Constraint: minimum=1
    #[serde(rename = "totalPages")]
    pub total_pages: i64,
    pub user: String,
}
///DEPRECATED: Price-based recurring orders are deprecated
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct RecurringGetRecurringOrderResponseVariant2 {
    #[serde(rename = "orderStatus")]
    pub order_status: RecurringOrderState,
    ///Constraint: minimum=1
    pub page: i64,
    pub price: Vec<RecurringPriceRecurringResponse>,
    ///Constraint: minimum=1
    #[serde(rename = "totalPages")]
    pub total_pages: i64,
    pub user: String,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct RecurringGetRecurringOrderResponseVariant {
    #[serde(rename = "orderStatus")]
    pub order_status: RecurringOrderState,
    ///Constraint: minimum=1
    pub page: i64,
    pub time: Vec<RecurringTimeRecurringResponse>,
    ///Constraint: minimum=1
    #[serde(rename = "totalPages")]
    pub total_pages: i64,
    pub user: String,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
pub enum RecurringGetRecurringOrderResponse {
    RecurringGetRecurringOrderResponseVariant(RecurringGetRecurringOrderResponseVariant),
    RecurringGetRecurringOrderResponseVariant2(RecurringGetRecurringOrderResponseVariant2),
    RecurringGetRecurringOrderResponseVariant3(RecurringGetRecurringOrderResponseVariant3),
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct RecurringGetRecurringOrderParams {
    #[serde(rename = "includeFailedTx")]
    pub include_failed_tx: bool,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub mint: Option<String>,
    #[serde(rename = "orderStatus")]
    pub order_status: RecurringOrderState,
    ///Constraint: minimum=1
    #[serde(skip_serializing_if = "Option::is_none")]
    pub page: Option<i64>,
    #[serde(rename = "recurringType")]
    pub recurring_type: RecurringRecurringOrderType,
    pub user: String,
}
/**Type of recurring order.
**DEPRECATED**: The 'price' value is deprecated.
*/
#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize, Default)]
pub enum RecurringRecurringOrderType {
    #[default]
    #[serde(rename = "time")]
    Time,
    #[serde(rename = "price")]
    Price,
    #[serde(rename = "all")]
    All,
}
impl RecurringRecurringOrderType {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::Time => "time",
            Self::Price => "price",
            Self::All => "all",
        }
    }
}
impl ::std::fmt::Display for RecurringRecurringOrderType {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        f.write_str(self.as_str())
    }
}
impl AsRef<str> for RecurringRecurringOrderType {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}
#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize, Default)]
pub enum RecurringOrderState {
    #[default]
    #[serde(rename = "active")]
    Active,
    #[serde(rename = "history")]
    History,
}
impl RecurringOrderState {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::Active => "active",
            Self::History => "history",
        }
    }
}
impl ::std::fmt::Display for RecurringOrderState {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        f.write_str(self.as_str())
    }
}
impl AsRef<str> for RecurringOrderState {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct RecurringExecuteRecurringResponse {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub error: Option<String>,
    ///Base-58 account which is the Recurring Order account
    #[serde(skip_serializing_if = "Option::is_none")]
    pub order: Option<String>,
    pub signature: String,
    pub status: RecurringExecuteRecurringResponseStatus,
}
#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize, Default)]
pub enum RecurringExecuteRecurringResponseStatus {
    #[default]
    #[serde(rename = "Success")]
    Success,
    #[serde(rename = "Failed")]
    Failed,
}
impl RecurringExecuteRecurringResponseStatus {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::Success => "Success",
            Self::Failed => "Failed",
        }
    }
}
impl ::std::fmt::Display for RecurringExecuteRecurringResponseStatus {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        f.write_str(self.as_str())
    }
}
impl AsRef<str> for RecurringExecuteRecurringResponseStatus {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct RecurringCreateRecurring {
    #[serde(rename = "inputMint")]
    pub input_mint: String,
    #[serde(rename = "outputMint")]
    pub output_mint: String,
    pub params: RecurringRecurringType,
    pub user: String,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
pub enum RecurringRecurringType {
    RecurringRecurringTypeVariant(RecurringRecurringTypeVariant),
    RecurringRecurringTypeVariant2(RecurringRecurringTypeVariant2),
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct RecurringTimeRecurringCreationParams {
    ///Constraint: minimum=0
    #[serde(rename = "inAmount")]
    pub in_amount: i64,
    ///In unix seconds
    pub interval: i64,
    #[serde(rename = "maxPrice", skip_serializing_if = "Option::is_none")]
    pub max_price: Option<f64>,
    #[serde(rename = "minPrice", skip_serializing_if = "Option::is_none")]
    pub min_price: Option<f64>,
    ///Constraint: minimum=0
    #[serde(rename = "numberOfOrders")]
    pub number_of_orders: i64,
    ///In unix timestamp
    #[serde(rename = "startAt", skip_serializing_if = "Option::is_none")]
    pub start_at: Option<i64>,
}
///DEPRECATED: Price-based recurring orders are deprecated
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct RecurringOpenIxArgsWithoutIdx {
    ///Constraint: minimum=0
    #[serde(rename = "depositAmount")]
    pub deposit_amount: i64,
    ///Constraint: minimum=0
    #[serde(rename = "incrementUsdcValue")]
    pub increment_usdc_value: i64,
    ///In unix seconds
    pub interval: i64,
    ///In unix timestamp
    #[serde(rename = "startAt", skip_serializing_if = "Option::is_none")]
    pub start_at: Option<i64>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct RecurringCloseRecurring {
    ///Base-58 account which is the Recurring Order account
    pub order: String,
    #[serde(rename = "recurringType")]
    pub recurring_type: RecurringCloseRecurringType,
    pub user: String,
}
/**- Type of recurring order to close.
- **DEPRECATED**: The 'price' value is deprecated.
*/
#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize, Default)]
pub enum RecurringCloseRecurringType {
    #[default]
    #[serde(rename = "time")]
    Time,
    #[serde(rename = "price")]
    Price,
}
impl RecurringCloseRecurringType {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::Time => "time",
            Self::Price => "price",
        }
    }
}
impl ::std::fmt::Display for RecurringCloseRecurringType {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        f.write_str(self.as_str())
    }
}
impl AsRef<str> for RecurringCloseRecurringType {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct RecurringAllRecurringResponseVariant2 {
    #[serde(rename = "closeTx")]
    pub close_tx: String,
    #[serde(rename = "closedBy")]
    pub closed_by: String,
    #[serde(rename = "createdAt")]
    pub created_at: chrono::DateTime<chrono::Utc>,
    #[serde(rename = "estimatedUsdcValueSpent")]
    pub estimated_usdc_value_spent: String,
    #[serde(rename = "inDeposited")]
    pub in_deposited: String,
    #[serde(rename = "inLeft")]
    pub in_left: String,
    ///Amount used to fulfill orders
    #[serde(rename = "inUsed")]
    pub in_used: String,
    #[serde(rename = "inWithdrawn")]
    pub in_withdrawn: String,
    #[serde(rename = "incrementalUsdValue")]
    pub incremental_usd_value: String,
    #[serde(rename = "inputMint")]
    pub input_mint: String,
    #[serde(rename = "openTx")]
    pub open_tx: String,
    #[serde(rename = "orderInterval")]
    pub order_interval: String,
    #[serde(rename = "orderKey")]
    pub order_key: String,
    ///Amount received in escrow without auto-withdraw enabled
    #[serde(rename = "outReceived")]
    pub out_received: String,
    /**Amount withdrawn from escrow account with/without auto-withdraw
    enabled
    */
    #[serde(rename = "outWithdrawn")]
    pub out_withdrawn: String,
    #[serde(rename = "outputMint")]
    pub output_mint: String,
    #[serde(rename = "rawEstimatedUsdcValueSpent")]
    pub raw_estimated_usdc_value_spent: String,
    #[serde(rename = "rawInDeposited")]
    pub raw_in_deposited: String,
    #[serde(rename = "rawInLeft")]
    pub raw_in_left: String,
    ///Amount used to fulfill orders
    #[serde(rename = "rawInUsed")]
    pub raw_in_used: String,
    #[serde(rename = "rawInWithdrawn")]
    pub raw_in_withdrawn: String,
    #[serde(rename = "rawIncrementalUsdValue")]
    pub raw_incremental_usd_value: String,
    ///Amount received in escrow without auto-withdraw enabled
    #[serde(rename = "rawOutReceived")]
    pub raw_out_received: String,
    /**Amount withdrawn from escrow account with/without auto-withdraw
    enabled
    */
    #[serde(rename = "rawOutWithdrawn")]
    pub raw_out_withdrawn: String,
    #[serde(rename = "rawSupposedUsdValue")]
    pub raw_supposed_usd_value: String,
    ///DEPRECATED: Price-based recurring orders are deprecated
    #[serde(rename = "recurringType")]
    pub recurring_type: RecurringAllRecurringResponseVariant2RecurringType,
    #[serde(rename = "startAt")]
    pub start_at: chrono::DateTime<chrono::Utc>,
    pub status: String,
    #[serde(rename = "supposedUsdValue")]
    pub supposed_usd_value: String,
    pub trades: Vec<RecurringOrderHistoryResponse>,
    #[serde(rename = "updatedAt")]
    pub updated_at: chrono::DateTime<chrono::Utc>,
    #[serde(rename = "userPubkey")]
    pub user_pubkey: String,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct RecurringAllRecurringResponseVariant {
    #[serde(rename = "closeTx")]
    pub close_tx: String,
    #[serde(rename = "createdAt")]
    pub created_at: chrono::DateTime<chrono::Utc>,
    #[serde(rename = "cycleFrequency")]
    pub cycle_frequency: String,
    #[serde(rename = "inAmountPerCycle")]
    pub in_amount_per_cycle: String,
    #[serde(rename = "inDeposited")]
    pub in_deposited: String,
    #[serde(rename = "inUsed")]
    pub in_used: String,
    #[serde(rename = "inWithdrawn")]
    pub in_withdrawn: String,
    #[serde(rename = "inputMint")]
    pub input_mint: String,
    #[serde(rename = "maxOutAmount")]
    pub max_out_amount: String,
    #[serde(rename = "minOutAmount")]
    pub min_out_amount: String,
    #[serde(rename = "openTx")]
    pub open_tx: String,
    #[serde(rename = "orderKey")]
    pub order_key: String,
    #[serde(rename = "outReceived")]
    pub out_received: String,
    #[serde(rename = "outWithdrawn")]
    pub out_withdrawn: String,
    #[serde(rename = "outputMint")]
    pub output_mint: String,
    #[serde(rename = "rawInAmountPerCycle")]
    pub raw_in_amount_per_cycle: String,
    #[serde(rename = "rawInDeposited")]
    pub raw_in_deposited: String,
    #[serde(rename = "rawInUsed")]
    pub raw_in_used: String,
    #[serde(rename = "rawInWithdrawn")]
    pub raw_in_withdrawn: String,
    #[serde(rename = "rawMaxOutAmount")]
    pub raw_max_out_amount: String,
    #[serde(rename = "rawMinOutAmount")]
    pub raw_min_out_amount: String,
    #[serde(rename = "rawOutReceived")]
    pub raw_out_received: String,
    #[serde(rename = "rawOutWithdrawn")]
    pub raw_out_withdrawn: String,
    #[serde(rename = "recurringType")]
    pub recurring_type: RecurringAllRecurringResponseVariantRecurringType,
    pub trades: Vec<RecurringOrderHistoryResponse>,
    #[serde(rename = "updatedAt")]
    pub updated_at: chrono::DateTime<chrono::Utc>,
    #[serde(rename = "userClosed")]
    pub user_closed: bool,
    #[serde(rename = "userPubkey")]
    pub user_pubkey: String,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
pub enum RecurringAllRecurringResponse {
    RecurringAllRecurringResponseVariant(RecurringAllRecurringResponseVariant),
    RecurringAllRecurringResponseVariant2(RecurringAllRecurringResponseVariant2),
}
///DEPRECATED: Price-based recurring orders are deprecated
#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize, Default)]
pub enum RecurringTimeRecurringResponseRecurringType {
    #[default]
    #[serde(rename = "price")]
    Price,
}
impl RecurringTimeRecurringResponseRecurringType {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::Price => "price",
        }
    }
}
impl ::std::fmt::Display for RecurringTimeRecurringResponseRecurringType {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        f.write_str(self.as_str())
    }
}
impl AsRef<str> for RecurringTimeRecurringResponseRecurringType {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct RecurringTimeRecurringResponse {
    #[serde(rename = "closeTx")]
    pub close_tx: String,
    #[serde(rename = "createdAt")]
    pub created_at: chrono::DateTime<chrono::Utc>,
    #[serde(rename = "cycleFrequency")]
    pub cycle_frequency: String,
    #[serde(rename = "inAmountPerCycle")]
    pub in_amount_per_cycle: String,
    #[serde(rename = "inDeposited")]
    pub in_deposited: String,
    #[serde(rename = "inUsed")]
    pub in_used: String,
    #[serde(rename = "inWithdrawn")]
    pub in_withdrawn: String,
    #[serde(rename = "inputMint")]
    pub input_mint: String,
    #[serde(rename = "maxOutAmount")]
    pub max_out_amount: String,
    #[serde(rename = "minOutAmount")]
    pub min_out_amount: String,
    #[serde(rename = "openTx")]
    pub open_tx: String,
    #[serde(rename = "orderKey")]
    pub order_key: String,
    #[serde(rename = "outReceived")]
    pub out_received: String,
    #[serde(rename = "outWithdrawn")]
    pub out_withdrawn: String,
    #[serde(rename = "outputMint")]
    pub output_mint: String,
    #[serde(rename = "rawInAmountPerCycle")]
    pub raw_in_amount_per_cycle: String,
    #[serde(rename = "rawInDeposited")]
    pub raw_in_deposited: String,
    #[serde(rename = "rawInUsed")]
    pub raw_in_used: String,
    #[serde(rename = "rawInWithdrawn")]
    pub raw_in_withdrawn: String,
    #[serde(rename = "rawMaxOutAmount")]
    pub raw_max_out_amount: String,
    #[serde(rename = "rawMinOutAmount")]
    pub raw_min_out_amount: String,
    #[serde(rename = "rawOutReceived")]
    pub raw_out_received: String,
    #[serde(rename = "rawOutWithdrawn")]
    pub raw_out_withdrawn: String,
    pub trades: Vec<RecurringOrderHistoryResponse>,
    #[serde(rename = "updatedAt")]
    pub updated_at: chrono::DateTime<chrono::Utc>,
    #[serde(rename = "userClosed")]
    pub user_closed: bool,
    #[serde(rename = "userPubkey")]
    pub user_pubkey: String,
}
///DEPRECATED: Price-based recurring orders are deprecated
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct RecurringPriceRecurringResponse {
    #[serde(rename = "closeTx")]
    pub close_tx: String,
    #[serde(rename = "closedBy")]
    pub closed_by: String,
    #[serde(rename = "createdAt")]
    pub created_at: chrono::DateTime<chrono::Utc>,
    #[serde(rename = "estimatedUsdcValueSpent")]
    pub estimated_usdc_value_spent: String,
    #[serde(rename = "inDeposited")]
    pub in_deposited: String,
    #[serde(rename = "inLeft")]
    pub in_left: String,
    ///Amount used to fulfill orders
    #[serde(rename = "inUsed")]
    pub in_used: String,
    #[serde(rename = "inWithdrawn")]
    pub in_withdrawn: String,
    #[serde(rename = "incrementalUsdValue")]
    pub incremental_usd_value: String,
    #[serde(rename = "inputMint")]
    pub input_mint: String,
    #[serde(rename = "openTx")]
    pub open_tx: String,
    #[serde(rename = "orderInterval")]
    pub order_interval: String,
    #[serde(rename = "orderKey")]
    pub order_key: String,
    ///Amount received in escrow without auto-withdraw enabled
    #[serde(rename = "outReceived")]
    pub out_received: String,
    /**Amount withdrawn from escrow account with/without auto-withdraw
    enabled
    */
    #[serde(rename = "outWithdrawn")]
    pub out_withdrawn: String,
    #[serde(rename = "outputMint")]
    pub output_mint: String,
    #[serde(rename = "rawEstimatedUsdcValueSpent")]
    pub raw_estimated_usdc_value_spent: String,
    #[serde(rename = "rawInDeposited")]
    pub raw_in_deposited: String,
    #[serde(rename = "rawInLeft")]
    pub raw_in_left: String,
    ///Amount used to fulfill orders
    #[serde(rename = "rawInUsed")]
    pub raw_in_used: String,
    #[serde(rename = "rawInWithdrawn")]
    pub raw_in_withdrawn: String,
    #[serde(rename = "rawIncrementalUsdValue")]
    pub raw_incremental_usd_value: String,
    ///Amount received in escrow without auto-withdraw enabled
    #[serde(rename = "rawOutReceived")]
    pub raw_out_received: String,
    /**Amount withdrawn from escrow account with/without auto-withdraw
    enabled
    */
    #[serde(rename = "rawOutWithdrawn")]
    pub raw_out_withdrawn: String,
    #[serde(rename = "rawSupposedUsdValue")]
    pub raw_supposed_usd_value: String,
    #[serde(rename = "startAt")]
    pub start_at: chrono::DateTime<chrono::Utc>,
    pub status: String,
    #[serde(rename = "supposedUsdValue")]
    pub supposed_usd_value: String,
    pub trades: Vec<RecurringOrderHistoryResponse>,
    #[serde(rename = "updatedAt")]
    pub updated_at: chrono::DateTime<chrono::Utc>,
    #[serde(rename = "userPubkey")]
    pub user_pubkey: String,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct RecurringOrderHistoryResponse {
    pub action: String,
    #[serde(rename = "confirmedAt")]
    pub confirmed_at: chrono::DateTime<chrono::Utc>,
    #[serde(rename = "feeAmount")]
    pub fee_amount: String,
    #[serde(rename = "feeMint")]
    pub fee_mint: String,
    #[serde(rename = "inputAmount")]
    pub input_amount: String,
    #[serde(rename = "inputMint")]
    pub input_mint: String,
    pub keeper: String,
    #[serde(rename = "orderKey")]
    pub order_key: String,
    #[serde(rename = "outputAmount")]
    pub output_amount: String,
    #[serde(rename = "outputMint")]
    pub output_mint: String,
    /**Extra metadata for sub-products which will never be queried

    with filters.


    See structs `DbOrderHistoryValueAverageMeta` and
    `DbOrderHistoryPerpetualMeta`

    to craft the JSONB object.
    */
    #[serde(rename = "productMeta", skip_serializing_if = "Option::is_none")]
    pub product_meta: Option<serde_json::Value>,
    #[serde(rename = "rawFeeAmount")]
    pub raw_fee_amount: String,
    #[serde(rename = "rawInputAmount")]
    pub raw_input_amount: String,
    #[serde(rename = "rawOutputAmount")]
    pub raw_output_amount: String,
    #[serde(rename = "txId")]
    pub tx_id: String,
}
#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize, Default)]
pub enum RecurringAllRecurringResponseVariantRecurringType {
    #[default]
    #[serde(rename = "time")]
    Time,
}
impl RecurringAllRecurringResponseVariantRecurringType {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::Time => "time",
        }
    }
}
impl ::std::fmt::Display for RecurringAllRecurringResponseVariantRecurringType {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        f.write_str(self.as_str())
    }
}
impl AsRef<str> for RecurringAllRecurringResponseVariantRecurringType {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}
///DEPRECATED: Price-based recurring orders are deprecated
#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize, Default)]
pub enum RecurringAllRecurringResponseVariant2RecurringType {
    #[default]
    #[serde(rename = "price")]
    Price,
}
impl RecurringAllRecurringResponseVariant2RecurringType {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::Price => "price",
        }
    }
}
impl ::std::fmt::Display for RecurringAllRecurringResponseVariant2RecurringType {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        f.write_str(self.as_str())
    }
}
impl AsRef<str> for RecurringAllRecurringResponseVariant2RecurringType {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}
#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize, Default)]
pub enum RecurringAllRecurringResponseRecurringType {
    #[default]
    #[serde(rename = "time")]
    Time,
}
impl RecurringAllRecurringResponseRecurringType {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::Time => "time",
        }
    }
}
impl ::std::fmt::Display for RecurringAllRecurringResponseRecurringType {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        f.write_str(self.as_str())
    }
}
impl AsRef<str> for RecurringAllRecurringResponseRecurringType {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct PriceV2PriceResponse {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub data: Option<PriceV2PriceResponseData>,
    #[serde(rename = "timeTaken", skip_serializing_if = "Option::is_none")]
    pub time_taken: Option<f64>,
}
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct PriceV2PriceResponseData {
    /// Additional properties matching the spec's
    /// `additionalProperties` value schema.
    #[serde(flatten)]
    pub additional_properties: std::collections::BTreeMap<String, PriceV2TokenPriceInfo>,
}
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct PriceV2TokenPriceInfo {
    #[serde(rename = "extraInfo", skip_serializing_if = "Option::is_none")]
    pub extra_info: Option<PriceV2ExtraInfo>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub id: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub price: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub r#type: Option<String>,
}
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct PriceV2ExtraInfo {
    #[serde(rename = "confidenceLevel", skip_serializing_if = "Option::is_none")]
    pub confidence_level: Option<PriceV2ExtraInfoConfidenceLevel>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub depth: Option<PriceV2Depth>,
    #[serde(rename = "lastSwappedPrice", skip_serializing_if = "Option::is_none")]
    pub last_swapped_price: Option<PriceV2LastSwappedPrice>,
    #[serde(rename = "quotedPrice", skip_serializing_if = "Option::is_none")]
    pub quoted_price: Option<PriceV2QuotedPrice>,
}
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct PriceV2QuotedPrice {
    #[serde(rename = "buyAt", skip_serializing_if = "Option::is_none")]
    pub buy_at: Option<i64>,
    #[serde(rename = "buyPrice", skip_serializing_if = "Option::is_none")]
    pub buy_price: Option<String>,
    #[serde(rename = "sellAt", skip_serializing_if = "Option::is_none")]
    pub sell_at: Option<i64>,
    #[serde(rename = "sellPrice", skip_serializing_if = "Option::is_none")]
    pub sell_price: Option<String>,
}
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct PriceV2LastSwappedPrice {
    #[serde(rename = "lastJupiterBuyAt", skip_serializing_if = "Option::is_none")]
    pub last_jupiter_buy_at: Option<i64>,
    #[serde(
        rename = "lastJupiterBuyPrice",
        skip_serializing_if = "Option::is_none"
    )]
    pub last_jupiter_buy_price: Option<String>,
    #[serde(rename = "lastJupiterSellAt", skip_serializing_if = "Option::is_none")]
    pub last_jupiter_sell_at: Option<i64>,
    #[serde(
        rename = "lastJupiterSellPrice",
        skip_serializing_if = "Option::is_none"
    )]
    pub last_jupiter_sell_price: Option<String>,
}
#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize, Default)]
pub enum PriceV2ExtraInfoConfidenceLevel {
    #[default]
    #[serde(rename = "high")]
    High,
    #[serde(rename = "medium")]
    Medium,
    #[serde(rename = "low")]
    Low,
}
impl PriceV2ExtraInfoConfidenceLevel {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::High => "high",
            Self::Medium => "medium",
            Self::Low => "low",
        }
    }
}
impl ::std::fmt::Display for PriceV2ExtraInfoConfidenceLevel {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        f.write_str(self.as_str())
    }
}
impl AsRef<str> for PriceV2ExtraInfoConfidenceLevel {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct PriceV2Depth {
    #[serde(
        rename = "buyPriceImpactRatio",
        skip_serializing_if = "Option::is_none"
    )]
    pub buy_price_impact_ratio: Option<PriceV2PriceImpactRatio>,
    #[serde(
        rename = "sellPriceImpactRatio",
        skip_serializing_if = "Option::is_none"
    )]
    pub sell_price_impact_ratio: Option<PriceV2PriceImpactRatio>,
}
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct PriceV2PriceImpactRatio {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub depth: Option<PriceV2PriceImpactRatioDepth>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub timestamp: Option<i64>,
}
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct PriceV2PriceImpactRatioDepth {
    #[serde(rename = "10", skip_serializing_if = "Option::is_none")]
    pub field_10: Option<f64>,
    #[serde(rename = "100", skip_serializing_if = "Option::is_none")]
    pub field_100: Option<f64>,
    #[serde(rename = "1000", skip_serializing_if = "Option::is_none")]
    pub field_1000: Option<f64>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PredictionExecuteResponse {
    ///Error message if the transaction failed, or `null` on success.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub error: Option<String>,
    ///Echoed from the request when provided.
    #[serde(rename = "requestId", skip_serializing_if = "Option::is_none")]
    pub request_id: Option<String>,
    ///Transaction signature (base58) when execution succeeds.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub signature: Option<String>,
    ///Transaction execution result.
    pub status: PredictionExecuteResponseStatus,
}
///Transaction execution result.
#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize, Default)]
pub enum PredictionExecuteResponseStatus {
    #[default]
    #[serde(rename = "Success")]
    Success,
    #[serde(rename = "Failed")]
    Failed,
}
impl PredictionExecuteResponseStatus {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::Success => "Success",
            Self::Failed => "Failed",
        }
    }
}
impl ::std::fmt::Display for PredictionExecuteResponseStatus {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        f.write_str(self.as_str())
    }
}
impl AsRef<str> for PredictionExecuteResponseStatus {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PredictionExecuteRequest {
    ///Optional. The `execution.context` object from the order build, passed unchanged. Validated against the signed transaction when present. For a Forecast swap it carries `jupiterSwapRequestId` and `ownerPubkey`.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub context: Option<PredictionExecuteRequestContext>,
    ///Optional client correlation ID, echoed back in the response.
    #[serde(rename = "requestId", skip_serializing_if = "Option::is_none")]
    pub request_id: Option<String>,
    ///Base64-encoded signed transaction from the order build.
    #[serde(rename = "signedTransaction")]
    pub signed_transaction: String,
}
impl PredictionExecuteRequest {
    /// Construct this request with every required wire field.
    pub fn new(signed_transaction: String) -> Self {
        Self {
            signed_transaction,
            context: None,
            request_id: None,
        }
    }
    /// Start a dependency-free builder with every required wire field.
    pub fn builder(signed_transaction: String) -> PredictionExecuteRequestBuilder {
        PredictionExecuteRequestBuilder::new(signed_transaction)
    }
}
/// Dependency-free builder for [`#struct_name`].
#[derive(Debug, Clone)]
#[must_use]
pub struct PredictionExecuteRequestBuilder {
    value: PredictionExecuteRequest,
}
impl PredictionExecuteRequestBuilder {
    /// Start a builder with every required wire field.
    pub fn new(signed_transaction: String) -> Self {
        Self {
            value: PredictionExecuteRequest::new(signed_transaction),
        }
    }
    #[doc = concat!("Set the optional `", "context", "` request field.")]
    #[must_use]
    pub fn context(mut self, context: PredictionExecuteRequestContext) -> Self {
        self.value.context = Some(context);
        self
    }
    #[doc = concat!("Set the optional `", "requestId", "` request field.")]
    #[must_use]
    pub fn request_id(mut self, request_id: String) -> Self {
        self.value.request_id = Some(request_id);
        self
    }
    /// Finish building the request model.
    pub fn build(self) -> PredictionExecuteRequest {
        self.value
    }
}
///Optional. The `execution.context` object from the order build, passed unchanged. Validated against the signed transaction when present. For a Forecast swap it carries `jupiterSwapRequestId` and `ownerPubkey`.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct PredictionExecuteRequestContext {
    /// Additional properties not explicitly defined in the schema
    #[serde(flatten)]
    pub additional_properties: std::collections::BTreeMap<String, serde_json::Value>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PredictionErrorResponse {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub code: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub doc_url: Option<String>,
    pub message: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub param: Option<String>,
    pub request_id: String,
    pub r#type: PredictionErrorResponseType,
}
#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize, Default)]
pub enum PredictionErrorResponseType {
    #[default]
    #[serde(rename = "invalid_request_error")]
    InvalidRequestError,
    #[serde(rename = "authentication_error")]
    AuthenticationError,
    #[serde(rename = "permission_error")]
    PermissionError,
    #[serde(rename = "idempotency_error")]
    IdempotencyError,
    #[serde(rename = "rate_limit_error")]
    RateLimitError,
    #[serde(rename = "api_error")]
    ApiError,
}
impl PredictionErrorResponseType {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::InvalidRequestError => "invalid_request_error",
            Self::AuthenticationError => "authentication_error",
            Self::PermissionError => "permission_error",
            Self::IdempotencyError => "idempotency_error",
            Self::RateLimitError => "rate_limit_error",
            Self::ApiError => "api_error",
        }
    }
}
impl ::std::fmt::Display for PredictionErrorResponseType {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        f.write_str(self.as_str())
    }
}
impl AsRef<str> for PredictionErrorResponseType {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PredictionCreateOrderRequest {
    ///Legacy whole-contract sell quantity (only when `isBuy` is `false`). Cannot express fractions; prefer contractsMicro or contractsDecimal. Provide only one of contracts, contractsMicro, or contractsDecimal.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub contracts: Option<PredictionCreateOrderRequestContracts>,
    ///Exact sell quantity as a decimal (e.g. 5.777773). Provide only one of contracts, contractsMicro, or contractsDecimal.
    #[serde(rename = "contractsDecimal", skip_serializing_if = "Option::is_none")]
    pub contracts_decimal: Option<PredictionCreateOrderRequestContractsDecimal>,
    ///Exact sell quantity in micro-contract units (1000000 = 1 contract). Provide only one of contracts, contractsMicro, or contractsDecimal.
    #[serde(rename = "contractsMicro", skip_serializing_if = "Option::is_none")]
    pub contracts_micro: Option<PredictionCreateOrderRequestContractsMicro>,
    ///Amount must conform to the token decimals used by the token mint in `depositMint`
    #[serde(rename = "depositAmount", skip_serializing_if = "Option::is_none")]
    pub deposit_amount: Option<PredictionCreateOrderRequestDepositAmount>,
    ///Mint address for the deposit token
    #[serde(rename = "depositMint", skip_serializing_if = "Option::is_none")]
    pub deposit_mint: Option<String>,
    #[serde(rename = "isBuy")]
    pub is_buy: bool,
    #[serde(rename = "isYes", skip_serializing_if = "Option::is_none")]
    pub is_yes: Option<bool>,
    ///Hashed or canonical market ID for buys
    ///Constraint: minLength=1
    #[serde(rename = "marketId", skip_serializing_if = "Option::is_none")]
    pub market_id: Option<String>,
    ///Order owner public key
    #[serde(rename = "ownerPubkey", skip_serializing_if = "Option::is_none")]
    pub owner_pubkey: Option<String>,
    ///Required for sells
    ///Constraint: minLength=32
    #[serde(rename = "positionPubkey", skip_serializing_if = "Option::is_none")]
    pub position_pubkey: Option<String>,
}
impl PredictionCreateOrderRequest {
    /// Construct this request with every required wire field.
    pub fn new(is_buy: bool) -> Self {
        Self {
            is_buy,
            contracts: None,
            contracts_decimal: None,
            contracts_micro: None,
            deposit_amount: None,
            deposit_mint: None,
            is_yes: None,
            market_id: None,
            owner_pubkey: None,
            position_pubkey: None,
        }
    }
    /// Start a dependency-free builder with every required wire field.
    pub fn builder(is_buy: bool) -> PredictionCreateOrderRequestBuilder {
        PredictionCreateOrderRequestBuilder::new(is_buy)
    }
}
/// Dependency-free builder for [`#struct_name`].
#[derive(Debug, Clone)]
#[must_use]
pub struct PredictionCreateOrderRequestBuilder {
    value: PredictionCreateOrderRequest,
}
impl PredictionCreateOrderRequestBuilder {
    /// Start a builder with every required wire field.
    pub fn new(is_buy: bool) -> Self {
        Self {
            value: PredictionCreateOrderRequest::new(is_buy),
        }
    }
    #[doc = concat!("Set the optional `", "contracts", "` request field.")]
    #[must_use]
    pub fn contracts(mut self, contracts: PredictionCreateOrderRequestContracts) -> Self {
        self.value.contracts = Some(contracts);
        self
    }
    #[doc = concat!("Set the optional `", "contractsDecimal", "` request field.")]
    #[must_use]
    pub fn contracts_decimal(
        mut self,
        contracts_decimal: PredictionCreateOrderRequestContractsDecimal,
    ) -> Self {
        self.value.contracts_decimal = Some(contracts_decimal);
        self
    }
    #[doc = concat!("Set the optional `", "contractsMicro", "` request field.")]
    #[must_use]
    pub fn contracts_micro(
        mut self,
        contracts_micro: PredictionCreateOrderRequestContractsMicro,
    ) -> Self {
        self.value.contracts_micro = Some(contracts_micro);
        self
    }
    #[doc = concat!("Set the optional `", "depositAmount", "` request field.")]
    #[must_use]
    pub fn deposit_amount(
        mut self,
        deposit_amount: PredictionCreateOrderRequestDepositAmount,
    ) -> Self {
        self.value.deposit_amount = Some(deposit_amount);
        self
    }
    #[doc = concat!("Set the optional `", "depositMint", "` request field.")]
    #[must_use]
    pub fn deposit_mint(mut self, deposit_mint: String) -> Self {
        self.value.deposit_mint = Some(deposit_mint);
        self
    }
    #[doc = concat!("Set the optional `", "isYes", "` request field.")]
    #[must_use]
    pub fn is_yes(mut self, is_yes: bool) -> Self {
        self.value.is_yes = Some(is_yes);
        self
    }
    #[doc = concat!("Set the optional `", "marketId", "` request field.")]
    #[must_use]
    pub fn market_id(mut self, market_id: String) -> Self {
        self.value.market_id = Some(market_id);
        self
    }
    #[doc = concat!("Set the optional `", "ownerPubkey", "` request field.")]
    #[must_use]
    pub fn owner_pubkey(mut self, owner_pubkey: String) -> Self {
        self.value.owner_pubkey = Some(owner_pubkey);
        self
    }
    #[doc = concat!("Set the optional `", "positionPubkey", "` request field.")]
    #[must_use]
    pub fn position_pubkey(mut self, position_pubkey: String) -> Self {
        self.value.position_pubkey = Some(position_pubkey);
        self
    }
    /// Finish building the request model.
    pub fn build(self) -> PredictionCreateOrderRequest {
        self.value
    }
}
///Amount must conform to the token decimals used by the token mint in `depositMint`
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
pub enum PredictionCreateOrderRequestDepositAmount {
    String(String),
    Number(f64),
}
///Exact sell quantity in micro-contract units (1000000 = 1 contract). Provide only one of contracts, contractsMicro, or contractsDecimal.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
pub enum PredictionCreateOrderRequestContractsMicro {
    String(String),
    Number(f64),
}
///Exact sell quantity as a decimal (e.g. 5.777773). Provide only one of contracts, contractsMicro, or contractsDecimal.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
pub enum PredictionCreateOrderRequestContractsDecimal {
    String(String),
    Number(f64),
}
///Legacy whole-contract sell quantity (only when `isBuy` is `false`). Cannot express fractions; prefer contractsMicro or contractsDecimal. Provide only one of contracts, contractsMicro, or contractsDecimal.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
pub enum PredictionCreateOrderRequestContracts {
    String(String),
    Number(f64),
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PostUltraV1ExecuteResponse {
    pub code: f64,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub error: Option<String>,
    #[serde(rename = "inputAmountResult", skip_serializing_if = "Option::is_none")]
    pub input_amount_result: Option<String>,
    #[serde(rename = "outputAmountResult", skip_serializing_if = "Option::is_none")]
    pub output_amount_result: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub signature: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub slot: Option<String>,
    pub status: PostUltraV1ExecuteResponseStatus,
    #[serde(rename = "swapEvents", skip_serializing_if = "Option::is_none")]
    pub swap_events: Option<Vec<PostUltraV1ExecuteResponseSwapEventsItem>>,
    #[serde(rename = "totalInputAmount", skip_serializing_if = "Option::is_none")]
    pub total_input_amount: Option<String>,
    #[serde(rename = "totalOutputAmount", skip_serializing_if = "Option::is_none")]
    pub total_output_amount: Option<String>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PostUltraV1ExecuteResponseSwapEventsItem {
    #[serde(rename = "inputAmount")]
    pub input_amount: String,
    #[serde(rename = "inputMint")]
    pub input_mint: String,
    #[serde(rename = "outputAmount")]
    pub output_amount: String,
    #[serde(rename = "outputMint")]
    pub output_mint: String,
}
#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize, Default)]
pub enum PostUltraV1ExecuteResponseStatus {
    #[default]
    #[serde(rename = "Success")]
    Success,
    #[serde(rename = "Failed")]
    Failed,
}
impl PostUltraV1ExecuteResponseStatus {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::Success => "Success",
            Self::Failed => "Failed",
        }
    }
}
impl ::std::fmt::Display for PostUltraV1ExecuteResponseStatus {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        f.write_str(self.as_str())
    }
}
impl AsRef<str> for PostUltraV1ExecuteResponseStatus {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PostTriggerV2OrdersPriceRequest {
    ///From /deposit/craft response
    #[serde(rename = "depositRequestId")]
    pub deposit_request_id: String,
    ///Base64-encoded signed deposit transaction
    #[serde(rename = "depositSignedTx")]
    pub deposit_signed_tx: String,
    ///Expiration timestamp (milliseconds)
    #[serde(rename = "expiresAt")]
    pub expires_at: f64,
    ///Amount in smallest unit
    #[serde(rename = "inputAmount")]
    pub input_amount: String,
    #[serde(rename = "inputMint")]
    pub input_mint: String,
    #[serde(rename = "orderType")]
    pub order_type: PostTriggerV2OrdersPriceRequestOrderType,
    #[serde(rename = "outputMint")]
    pub output_mint: String,
    ///Stop-loss price (OCO/OTOCO)
    #[serde(rename = "slPriceUsd", skip_serializing_if = "Option::is_none")]
    pub sl_price_usd: Option<f64>,
    ///Stop-loss slippage (OCO/OTOCO)
    #[serde(rename = "slSlippageBps", skip_serializing_if = "Option::is_none")]
    pub sl_slippage_bps: Option<f64>,
    ///Slippage tolerance (0-10000 bps)
    #[serde(rename = "slippageBps", skip_serializing_if = "Option::is_none")]
    pub slippage_bps: Option<f64>,
    ///Take-profit price (OCO/OTOCO)
    #[serde(rename = "tpPriceUsd", skip_serializing_if = "Option::is_none")]
    pub tp_price_usd: Option<f64>,
    ///Take-profit slippage (OCO/OTOCO)
    #[serde(rename = "tpSlippageBps", skip_serializing_if = "Option::is_none")]
    pub tp_slippage_bps: Option<f64>,
    ///Trailing stop loss trail distance in basis points (50-9000). Single orders only; set instead of triggerPriceUsd. Direction from triggerCondition: below = sell-below (triggerMint === inputMint), above = buy-above (triggerMint === outputMint).
    ///Constraint: minimum=50, maximum=9000
    #[serde(rename = "trailingBps", skip_serializing_if = "Option::is_none")]
    pub trailing_bps: Option<f64>,
    ///Single/OTOCO only
    #[serde(rename = "triggerCondition", skip_serializing_if = "Option::is_none")]
    pub trigger_condition: Option<PostTriggerV2OrdersPriceRequestTriggerCondition>,
    ///Token mint to monitor for price
    #[serde(rename = "triggerMint")]
    pub trigger_mint: String,
    ///Single/OTOCO trigger price. For single orders, required unless trailingBps is set.
    #[serde(rename = "triggerPriceUsd", skip_serializing_if = "Option::is_none")]
    pub trigger_price_usd: Option<f64>,
    #[serde(rename = "userPubkey")]
    pub user_pubkey: String,
}
impl PostTriggerV2OrdersPriceRequest {
    /// Construct this request with every required wire field.
    pub fn new(
        deposit_request_id: String,
        deposit_signed_tx: String,
        expires_at: f64,
        input_amount: String,
        input_mint: String,
        order_type: PostTriggerV2OrdersPriceRequestOrderType,
        output_mint: String,
        trigger_mint: String,
        user_pubkey: String,
    ) -> Self {
        Self {
            deposit_request_id,
            deposit_signed_tx,
            expires_at,
            input_amount,
            input_mint,
            order_type,
            output_mint,
            trigger_mint,
            user_pubkey,
            sl_price_usd: None,
            sl_slippage_bps: None,
            slippage_bps: None,
            tp_price_usd: None,
            tp_slippage_bps: None,
            trailing_bps: None,
            trigger_condition: None,
            trigger_price_usd: None,
        }
    }
    /// Start a dependency-free builder with every required wire field.
    pub fn builder(
        deposit_request_id: String,
        deposit_signed_tx: String,
        expires_at: f64,
        input_amount: String,
        input_mint: String,
        order_type: PostTriggerV2OrdersPriceRequestOrderType,
        output_mint: String,
        trigger_mint: String,
        user_pubkey: String,
    ) -> PostTriggerV2OrdersPriceRequestBuilder {
        PostTriggerV2OrdersPriceRequestBuilder::new(
            deposit_request_id,
            deposit_signed_tx,
            expires_at,
            input_amount,
            input_mint,
            order_type,
            output_mint,
            trigger_mint,
            user_pubkey,
        )
    }
}
/// Dependency-free builder for [`#struct_name`].
#[derive(Debug, Clone)]
#[must_use]
pub struct PostTriggerV2OrdersPriceRequestBuilder {
    value: PostTriggerV2OrdersPriceRequest,
}
impl PostTriggerV2OrdersPriceRequestBuilder {
    /// Start a builder with every required wire field.
    pub fn new(
        deposit_request_id: String,
        deposit_signed_tx: String,
        expires_at: f64,
        input_amount: String,
        input_mint: String,
        order_type: PostTriggerV2OrdersPriceRequestOrderType,
        output_mint: String,
        trigger_mint: String,
        user_pubkey: String,
    ) -> Self {
        Self {
            value: PostTriggerV2OrdersPriceRequest::new(
                deposit_request_id,
                deposit_signed_tx,
                expires_at,
                input_amount,
                input_mint,
                order_type,
                output_mint,
                trigger_mint,
                user_pubkey,
            ),
        }
    }
    #[doc = concat!("Set the optional `", "slPriceUsd", "` request field.")]
    #[must_use]
    pub fn sl_price_usd(mut self, sl_price_usd: f64) -> Self {
        self.value.sl_price_usd = Some(sl_price_usd);
        self
    }
    #[doc = concat!("Set the optional `", "slSlippageBps", "` request field.")]
    #[must_use]
    pub fn sl_slippage_bps(mut self, sl_slippage_bps: f64) -> Self {
        self.value.sl_slippage_bps = Some(sl_slippage_bps);
        self
    }
    #[doc = concat!("Set the optional `", "slippageBps", "` request field.")]
    #[must_use]
    pub fn slippage_bps(mut self, slippage_bps: f64) -> Self {
        self.value.slippage_bps = Some(slippage_bps);
        self
    }
    #[doc = concat!("Set the optional `", "tpPriceUsd", "` request field.")]
    #[must_use]
    pub fn tp_price_usd(mut self, tp_price_usd: f64) -> Self {
        self.value.tp_price_usd = Some(tp_price_usd);
        self
    }
    #[doc = concat!("Set the optional `", "tpSlippageBps", "` request field.")]
    #[must_use]
    pub fn tp_slippage_bps(mut self, tp_slippage_bps: f64) -> Self {
        self.value.tp_slippage_bps = Some(tp_slippage_bps);
        self
    }
    #[doc = concat!("Set the optional `", "trailingBps", "` request field.")]
    #[must_use]
    pub fn trailing_bps(mut self, trailing_bps: f64) -> Self {
        self.value.trailing_bps = Some(trailing_bps);
        self
    }
    #[doc = concat!("Set the optional `", "triggerCondition", "` request field.")]
    #[must_use]
    pub fn trigger_condition(
        mut self,
        trigger_condition: PostTriggerV2OrdersPriceRequestTriggerCondition,
    ) -> Self {
        self.value.trigger_condition = Some(trigger_condition);
        self
    }
    #[doc = concat!("Set the optional `", "triggerPriceUsd", "` request field.")]
    #[must_use]
    pub fn trigger_price_usd(mut self, trigger_price_usd: f64) -> Self {
        self.value.trigger_price_usd = Some(trigger_price_usd);
        self
    }
    /// Finish building the request model.
    pub fn build(self) -> PostTriggerV2OrdersPriceRequest {
        self.value
    }
}
///Single/OTOCO only
#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize, Default)]
pub enum PostTriggerV2OrdersPriceRequestTriggerCondition {
    #[default]
    #[serde(rename = "above")]
    Above,
    #[serde(rename = "below")]
    Below,
}
impl PostTriggerV2OrdersPriceRequestTriggerCondition {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::Above => "above",
            Self::Below => "below",
        }
    }
}
impl ::std::fmt::Display for PostTriggerV2OrdersPriceRequestTriggerCondition {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        f.write_str(self.as_str())
    }
}
impl AsRef<str> for PostTriggerV2OrdersPriceRequestTriggerCondition {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}
#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize, Default)]
pub enum PostTriggerV2OrdersPriceRequestOrderType {
    #[default]
    #[serde(rename = "single")]
    Single,
    #[serde(rename = "oco")]
    Oco,
    #[serde(rename = "otoco")]
    Otoco,
}
impl PostTriggerV2OrdersPriceRequestOrderType {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::Single => "single",
            Self::Oco => "oco",
            Self::Otoco => "otoco",
        }
    }
}
impl ::std::fmt::Display for PostTriggerV2OrdersPriceRequestOrderType {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        f.write_str(self.as_str())
    }
}
impl AsRef<str> for PostTriggerV2OrdersPriceRequestOrderType {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PostTriggerV2OrdersDcaRequest {
    ///ISO-8601 time to start the first round. Defaults to now, max 30 days in the future.
    #[serde(rename = "beginFillAt", skip_serializing_if = "Option::is_none")]
    pub begin_fill_at: Option<String>,
    ///requestId from the deposit craft response
    #[serde(rename = "depositRequestId")]
    pub deposit_request_id: String,
    ///Base64-encoded signed deposit transaction
    #[serde(rename = "depositSignedTx")]
    pub deposit_signed_tx: String,
    ///Total amount to DCA in smallest units. Dust from uneven division is added to the last round.
    #[serde(rename = "inputAmount")]
    pub input_amount: String,
    ///Mint of the token to sell
    #[serde(rename = "inputMint")]
    pub input_mint: String,
    ///Seconds between rounds (60 to 31,536,000, i.e. 1 minute to 1 year)
    ///Constraint: minimum=60, maximum=31536000
    #[serde(rename = "intervalSeconds")]
    pub interval_seconds: f64,
    ///Earn While You Wait. When true, idle funds earn Jupiter Lend yield between rounds. Requires orderType time_based, a supported stablecoin input, and a deposit crafted with jlMint. Default false.
    #[serde(rename = "jlEnabled", skip_serializing_if = "Option::is_none")]
    pub jl_enabled: Option<bool>,
    ///Jupiter Lend earn token for the input stablecoin (from GET /lend/v1/earn/tokens, the address whose assetAddress is the inputMint). Required when jlEnabled is true.
    #[serde(rename = "jlMint", skip_serializing_if = "Option::is_none")]
    pub jl_mint: Option<String>,
    ///Upper USD price bound. Price-conditional only.
    #[serde(rename = "maxPriceUsd", skip_serializing_if = "Option::is_none")]
    pub max_price_usd: Option<f64>,
    ///Lower USD price bound. Price-conditional only.
    #[serde(rename = "minPriceUsd", skip_serializing_if = "Option::is_none")]
    pub min_price_usd: Option<f64>,
    ///Number of rounds to split the deposit into (minimum 2). No fixed upper limit, but each round must be worth at least 10 USD, so the practical maximum is floor(total deposit USD / 10).
    ///Constraint: minimum=2
    #[serde(rename = "orderCount")]
    pub order_count: f64,
    ///time_based runs every interval; price_conditional only fills while the trigger mint price is within the band.
    #[serde(rename = "orderType", skip_serializing_if = "Option::is_none")]
    pub order_type: Option<PostTriggerV2OrdersDcaRequestOrderType>,
    ///Mint of the token to buy
    #[serde(rename = "outputMint")]
    pub output_mint: String,
    ///Mint whose USD price is checked against the band. Required for price_conditional. Must be a mint with a supported USD price (in practice the volatile leg / outputMint); a stablecoin such as USDC returns "Trigger mint is not supported". Ignored for time_based.
    #[serde(rename = "triggerMint", skip_serializing_if = "Option::is_none")]
    pub trigger_mint: Option<String>,
    ///Your wallet public key (must match the JWT)
    #[serde(rename = "userPubkey")]
    pub user_pubkey: String,
}
impl PostTriggerV2OrdersDcaRequest {
    /// Construct this request with every required wire field.
    pub fn new(
        deposit_request_id: String,
        deposit_signed_tx: String,
        input_amount: String,
        input_mint: String,
        interval_seconds: f64,
        order_count: f64,
        output_mint: String,
        user_pubkey: String,
    ) -> Self {
        Self {
            deposit_request_id,
            deposit_signed_tx,
            input_amount,
            input_mint,
            interval_seconds,
            order_count,
            output_mint,
            user_pubkey,
            begin_fill_at: None,
            jl_enabled: None,
            jl_mint: None,
            max_price_usd: None,
            min_price_usd: None,
            order_type: None,
            trigger_mint: None,
        }
    }
    /// Start a dependency-free builder with every required wire field.
    pub fn builder(
        deposit_request_id: String,
        deposit_signed_tx: String,
        input_amount: String,
        input_mint: String,
        interval_seconds: f64,
        order_count: f64,
        output_mint: String,
        user_pubkey: String,
    ) -> PostTriggerV2OrdersDcaRequestBuilder {
        PostTriggerV2OrdersDcaRequestBuilder::new(
            deposit_request_id,
            deposit_signed_tx,
            input_amount,
            input_mint,
            interval_seconds,
            order_count,
            output_mint,
            user_pubkey,
        )
    }
}
/// Dependency-free builder for [`#struct_name`].
#[derive(Debug, Clone)]
#[must_use]
pub struct PostTriggerV2OrdersDcaRequestBuilder {
    value: PostTriggerV2OrdersDcaRequest,
}
impl PostTriggerV2OrdersDcaRequestBuilder {
    /// Start a builder with every required wire field.
    pub fn new(
        deposit_request_id: String,
        deposit_signed_tx: String,
        input_amount: String,
        input_mint: String,
        interval_seconds: f64,
        order_count: f64,
        output_mint: String,
        user_pubkey: String,
    ) -> Self {
        Self {
            value: PostTriggerV2OrdersDcaRequest::new(
                deposit_request_id,
                deposit_signed_tx,
                input_amount,
                input_mint,
                interval_seconds,
                order_count,
                output_mint,
                user_pubkey,
            ),
        }
    }
    #[doc = concat!("Set the optional `", "beginFillAt", "` request field.")]
    #[must_use]
    pub fn begin_fill_at(mut self, begin_fill_at: String) -> Self {
        self.value.begin_fill_at = Some(begin_fill_at);
        self
    }
    #[doc = concat!("Set the optional `", "jlEnabled", "` request field.")]
    #[must_use]
    pub fn jl_enabled(mut self, jl_enabled: bool) -> Self {
        self.value.jl_enabled = Some(jl_enabled);
        self
    }
    #[doc = concat!("Set the optional `", "jlMint", "` request field.")]
    #[must_use]
    pub fn jl_mint(mut self, jl_mint: String) -> Self {
        self.value.jl_mint = Some(jl_mint);
        self
    }
    #[doc = concat!("Set the optional `", "maxPriceUsd", "` request field.")]
    #[must_use]
    pub fn max_price_usd(mut self, max_price_usd: f64) -> Self {
        self.value.max_price_usd = Some(max_price_usd);
        self
    }
    #[doc = concat!("Set the optional `", "minPriceUsd", "` request field.")]
    #[must_use]
    pub fn min_price_usd(mut self, min_price_usd: f64) -> Self {
        self.value.min_price_usd = Some(min_price_usd);
        self
    }
    #[doc = concat!("Set the optional `", "orderType", "` request field.")]
    #[must_use]
    pub fn order_type(mut self, order_type: PostTriggerV2OrdersDcaRequestOrderType) -> Self {
        self.value.order_type = Some(order_type);
        self
    }
    #[doc = concat!("Set the optional `", "triggerMint", "` request field.")]
    #[must_use]
    pub fn trigger_mint(mut self, trigger_mint: String) -> Self {
        self.value.trigger_mint = Some(trigger_mint);
        self
    }
    /// Finish building the request model.
    pub fn build(self) -> PostTriggerV2OrdersDcaRequest {
        self.value
    }
}
///time_based runs every interval; price_conditional only fills while the trigger mint price is within the band.
#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize, Default)]
pub enum PostTriggerV2OrdersDcaRequestOrderType {
    #[default]
    #[serde(rename = "time_based")]
    TimeBased,
    #[serde(rename = "price_conditional")]
    PriceConditional,
}
impl PostTriggerV2OrdersDcaRequestOrderType {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::TimeBased => "time_based",
            Self::PriceConditional => "price_conditional",
        }
    }
}
impl ::std::fmt::Display for PostTriggerV2OrdersDcaRequestOrderType {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        f.write_str(self.as_str())
    }
}
impl AsRef<str> for PostTriggerV2OrdersDcaRequestOrderType {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PostTriggerV2DepositCraftRequest {
    ///Amount in smallest unit (e.g. lamports for SOL)
    pub amount: String,
    ///Mint address of the token to deposit
    #[serde(rename = "inputMint")]
    pub input_mint: String,
    ///For Earn While You Wait DCA orders only. The Jupiter Lend earn token for the input stablecoin (from GET /lend/v1/earn/tokens). Crafts a deposit into Jupiter Lend; the response returns jlTokenAccount instead of inputTokenAccount.
    #[serde(rename = "jlMint", skip_serializing_if = "Option::is_none")]
    pub jl_mint: Option<String>,
    ///Required when orderType is price (single for standalone orders, oco for OCO orders, otoco for OTOCO orders). Must be omitted when orderType is dca.
    #[serde(rename = "orderSubType", skip_serializing_if = "Option::is_none")]
    pub order_sub_type: Option<PostTriggerV2DepositCraftRequestOrderSubType>,
    ///Order type for the deposit. Use price for price trigger orders, or dca for dollar-cost averaging orders.
    #[serde(rename = "orderType")]
    pub order_type: PostTriggerV2DepositCraftRequestOrderType,
    ///Mint address of the desired output token
    #[serde(rename = "outputMint")]
    pub output_mint: String,
    ///Your wallet public key
    #[serde(rename = "userAddress")]
    pub user_address: String,
}
impl PostTriggerV2DepositCraftRequest {
    /// Construct this request with every required wire field.
    pub fn new(
        amount: String,
        input_mint: String,
        order_type: PostTriggerV2DepositCraftRequestOrderType,
        output_mint: String,
        user_address: String,
    ) -> Self {
        Self {
            amount,
            input_mint,
            order_type,
            output_mint,
            user_address,
            jl_mint: None,
            order_sub_type: None,
        }
    }
    /// Start a dependency-free builder with every required wire field.
    pub fn builder(
        amount: String,
        input_mint: String,
        order_type: PostTriggerV2DepositCraftRequestOrderType,
        output_mint: String,
        user_address: String,
    ) -> PostTriggerV2DepositCraftRequestBuilder {
        PostTriggerV2DepositCraftRequestBuilder::new(
            amount,
            input_mint,
            order_type,
            output_mint,
            user_address,
        )
    }
}
/// Dependency-free builder for [`#struct_name`].
#[derive(Debug, Clone)]
#[must_use]
pub struct PostTriggerV2DepositCraftRequestBuilder {
    value: PostTriggerV2DepositCraftRequest,
}
impl PostTriggerV2DepositCraftRequestBuilder {
    /// Start a builder with every required wire field.
    pub fn new(
        amount: String,
        input_mint: String,
        order_type: PostTriggerV2DepositCraftRequestOrderType,
        output_mint: String,
        user_address: String,
    ) -> Self {
        Self {
            value: PostTriggerV2DepositCraftRequest::new(
                amount,
                input_mint,
                order_type,
                output_mint,
                user_address,
            ),
        }
    }
    #[doc = concat!("Set the optional `", "jlMint", "` request field.")]
    #[must_use]
    pub fn jl_mint(mut self, jl_mint: String) -> Self {
        self.value.jl_mint = Some(jl_mint);
        self
    }
    #[doc = concat!("Set the optional `", "orderSubType", "` request field.")]
    #[must_use]
    pub fn order_sub_type(
        mut self,
        order_sub_type: PostTriggerV2DepositCraftRequestOrderSubType,
    ) -> Self {
        self.value.order_sub_type = Some(order_sub_type);
        self
    }
    /// Finish building the request model.
    pub fn build(self) -> PostTriggerV2DepositCraftRequest {
        self.value
    }
}
///Order type for the deposit. Use price for price trigger orders, or dca for dollar-cost averaging orders.
#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize, Default)]
pub enum PostTriggerV2DepositCraftRequestOrderType {
    #[default]
    #[serde(rename = "price")]
    Price,
    #[serde(rename = "dca")]
    Dca,
}
impl PostTriggerV2DepositCraftRequestOrderType {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::Price => "price",
            Self::Dca => "dca",
        }
    }
}
impl ::std::fmt::Display for PostTriggerV2DepositCraftRequestOrderType {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        f.write_str(self.as_str())
    }
}
impl AsRef<str> for PostTriggerV2DepositCraftRequestOrderType {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}
///Required when orderType is price (single for standalone orders, oco for OCO orders, otoco for OTOCO orders). Must be omitted when orderType is dca.
#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize, Default)]
pub enum PostTriggerV2DepositCraftRequestOrderSubType {
    #[default]
    #[serde(rename = "single")]
    Single,
    #[serde(rename = "oco")]
    Oco,
    #[serde(rename = "otoco")]
    Otoco,
}
impl PostTriggerV2DepositCraftRequestOrderSubType {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::Single => "single",
            Self::Oco => "oco",
            Self::Otoco => "otoco",
        }
    }
}
impl ::std::fmt::Display for PostTriggerV2DepositCraftRequestOrderSubType {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        f.write_str(self.as_str())
    }
}
impl AsRef<str> for PostTriggerV2DepositCraftRequestOrderSubType {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PostTriggerV2AuthVerifyRequestVariant2 {
    ///Base64-encoded signed transaction
    #[serde(rename = "signedTransaction")]
    pub signed_transaction: String,
    pub r#type: PostTriggerV2AuthVerifyRequestVariant2Type,
    #[serde(rename = "walletPubkey")]
    pub wallet_pubkey: String,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PostTriggerV2AuthVerifyRequestVariant {
    ///Base58-encoded signature
    pub signature: String,
    pub r#type: PostTriggerV2AuthVerifyRequestVariantType,
    #[serde(rename = "walletPubkey")]
    pub wallet_pubkey: String,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
pub enum PostTriggerV2AuthVerifyRequest {
    PostTriggerV2AuthVerifyRequestVariant(PostTriggerV2AuthVerifyRequestVariant),
    PostTriggerV2AuthVerifyRequestVariant2(PostTriggerV2AuthVerifyRequestVariant2),
}
#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize, Default)]
pub enum PostTriggerV2AuthVerifyRequestVariantType {
    #[default]
    #[serde(rename = "message")]
    Message,
}
impl PostTriggerV2AuthVerifyRequestVariantType {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::Message => "message",
        }
    }
}
impl ::std::fmt::Display for PostTriggerV2AuthVerifyRequestVariantType {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        f.write_str(self.as_str())
    }
}
impl AsRef<str> for PostTriggerV2AuthVerifyRequestVariantType {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}
#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize, Default)]
pub enum PostTriggerV2AuthVerifyRequestVariant2Type {
    #[default]
    #[serde(rename = "transaction")]
    Transaction,
}
impl PostTriggerV2AuthVerifyRequestVariant2Type {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::Transaction => "transaction",
        }
    }
}
impl ::std::fmt::Display for PostTriggerV2AuthVerifyRequestVariant2Type {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        f.write_str(self.as_str())
    }
}
impl AsRef<str> for PostTriggerV2AuthVerifyRequestVariant2Type {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}
#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize, Default)]
pub enum PostTriggerV2AuthVerifyRequestTypeTransaction {
    #[default]
    #[serde(rename = "transaction")]
    Transaction,
}
impl PostTriggerV2AuthVerifyRequestTypeTransaction {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::Transaction => "transaction",
        }
    }
}
impl ::std::fmt::Display for PostTriggerV2AuthVerifyRequestTypeTransaction {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        f.write_str(self.as_str())
    }
}
impl AsRef<str> for PostTriggerV2AuthVerifyRequestTypeTransaction {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}
#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize, Default)]
pub enum PostTriggerV2AuthVerifyRequestType {
    #[default]
    #[serde(rename = "message")]
    Message,
}
impl PostTriggerV2AuthVerifyRequestType {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::Message => "message",
        }
    }
}
impl ::std::fmt::Display for PostTriggerV2AuthVerifyRequestType {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        f.write_str(self.as_str())
    }
}
impl AsRef<str> for PostTriggerV2AuthVerifyRequestType {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PostTriggerV2AuthChallengeResponseVariant2 {
    ///Base64-encoded transaction with memo instruction
    pub transaction: String,
    pub r#type: PostTriggerV2AuthChallengeResponseVariant2Type,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PostTriggerV2AuthChallengeResponseVariant {
    ///Message to sign
    pub challenge: String,
    pub r#type: PostTriggerV2AuthChallengeResponseVariantType,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
pub enum PostTriggerV2AuthChallengeResponse {
    PostTriggerV2AuthChallengeResponseVariant(PostTriggerV2AuthChallengeResponseVariant),
    PostTriggerV2AuthChallengeResponseVariant2(PostTriggerV2AuthChallengeResponseVariant2),
}
#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize, Default)]
pub enum PostTriggerV2AuthChallengeResponseVariantType {
    #[default]
    #[serde(rename = "message")]
    Message,
}
impl PostTriggerV2AuthChallengeResponseVariantType {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::Message => "message",
        }
    }
}
impl ::std::fmt::Display for PostTriggerV2AuthChallengeResponseVariantType {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        f.write_str(self.as_str())
    }
}
impl AsRef<str> for PostTriggerV2AuthChallengeResponseVariantType {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}
#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize, Default)]
pub enum PostTriggerV2AuthChallengeResponseVariant2Type {
    #[default]
    #[serde(rename = "transaction")]
    Transaction,
}
impl PostTriggerV2AuthChallengeResponseVariant2Type {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::Transaction => "transaction",
        }
    }
}
impl ::std::fmt::Display for PostTriggerV2AuthChallengeResponseVariant2Type {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        f.write_str(self.as_str())
    }
}
impl AsRef<str> for PostTriggerV2AuthChallengeResponseVariant2Type {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}
#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize, Default)]
pub enum PostTriggerV2AuthChallengeResponseTypeTransaction {
    #[default]
    #[serde(rename = "transaction")]
    Transaction,
}
impl PostTriggerV2AuthChallengeResponseTypeTransaction {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::Transaction => "transaction",
        }
    }
}
impl ::std::fmt::Display for PostTriggerV2AuthChallengeResponseTypeTransaction {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        f.write_str(self.as_str())
    }
}
impl AsRef<str> for PostTriggerV2AuthChallengeResponseTypeTransaction {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}
#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize, Default)]
pub enum PostTriggerV2AuthChallengeResponseType {
    #[default]
    #[serde(rename = "message")]
    Message,
}
impl PostTriggerV2AuthChallengeResponseType {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::Message => "message",
        }
    }
}
impl ::std::fmt::Display for PostTriggerV2AuthChallengeResponseType {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        f.write_str(self.as_str())
    }
}
impl AsRef<str> for PostTriggerV2AuthChallengeResponseType {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PostTriggerV2AuthChallengeRequest {
    ///Challenge type. Use `transaction` for hardware wallets.
    pub r#type: PostTriggerV2AuthChallengeRequestType,
    ///Your Solana wallet public key
    #[serde(rename = "walletPubkey")]
    pub wallet_pubkey: String,
}
///Challenge type. Use `transaction` for hardware wallets.
#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize, Default)]
pub enum PostTriggerV2AuthChallengeRequestType {
    #[default]
    #[serde(rename = "message")]
    Message,
    #[serde(rename = "transaction")]
    Transaction,
}
impl PostTriggerV2AuthChallengeRequestType {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::Message => "message",
            Self::Transaction => "transaction",
        }
    }
}
impl ::std::fmt::Display for PostTriggerV2AuthChallengeRequestType {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        f.write_str(self.as_str())
    }
}
impl AsRef<str> for PostTriggerV2AuthChallengeRequestType {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PostTriggerV1ExecuteResponse500 {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cause: Option<String>,
    pub code: f64,
    pub error: String,
    ///Signature of the transaction, if generated
    #[serde(skip_serializing_if = "Option::is_none")]
    pub signature: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub status: Option<PostTriggerV1ExecuteResponse500Status>,
}
#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize, Default)]
pub enum PostTriggerV1ExecuteResponse500Status {
    #[default]
    #[serde(rename = "Failed")]
    Failed,
}
impl PostTriggerV1ExecuteResponse500Status {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::Failed => "Failed",
        }
    }
}
impl ::std::fmt::Display for PostTriggerV1ExecuteResponse500Status {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        f.write_str(self.as_str())
    }
}
impl AsRef<str> for PostTriggerV1ExecuteResponse500Status {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PostTriggerV1ExecuteResponse400 {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cause: Option<String>,
    pub code: f64,
    pub error: String,
    ///Signature of the transaction, if generated
    #[serde(skip_serializing_if = "Option::is_none")]
    pub signature: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub status: Option<PostTriggerV1ExecuteResponse400Status>,
}
#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize, Default)]
pub enum PostTriggerV1ExecuteResponse400Status {
    #[default]
    #[serde(rename = "Failed")]
    Failed,
}
impl PostTriggerV1ExecuteResponse400Status {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::Failed => "Failed",
        }
    }
}
impl ::std::fmt::Display for PostTriggerV1ExecuteResponse400Status {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        f.write_str(self.as_str())
    }
}
impl AsRef<str> for PostTriggerV1ExecuteResponse400Status {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PostTriggerV1ExecuteResponse {
    pub code: f64,
    ///Signature of the successful transaction
    pub signature: String,
    pub status: PostTriggerV1ExecuteResponseStatus,
}
#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize, Default)]
pub enum PostTriggerV1ExecuteResponseStatus {
    #[default]
    #[serde(rename = "Success")]
    Success,
    #[serde(rename = "Failed")]
    Failed,
}
impl PostTriggerV1ExecuteResponseStatus {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::Success => "Success",
            Self::Failed => "Failed",
        }
    }
}
impl ::std::fmt::Display for PostTriggerV1ExecuteResponseStatus {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        f.write_str(self.as_str())
    }
}
impl AsRef<str> for PostTriggerV1ExecuteResponseStatus {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PostTriggerV1CreateOrderResponse500 {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cause: Option<String>,
    pub code: f64,
    pub error: String,
    ///Signature of the transaction, if generated
    #[serde(skip_serializing_if = "Option::is_none")]
    pub signature: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub status: Option<PostTriggerV1CreateOrderResponse500Status>,
}
#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize, Default)]
pub enum PostTriggerV1CreateOrderResponse500Status {
    #[default]
    #[serde(rename = "Failed")]
    Failed,
}
impl PostTriggerV1CreateOrderResponse500Status {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::Failed => "Failed",
        }
    }
}
impl ::std::fmt::Display for PostTriggerV1CreateOrderResponse500Status {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        f.write_str(self.as_str())
    }
}
impl AsRef<str> for PostTriggerV1CreateOrderResponse500Status {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PostTriggerV1CreateOrderResponse400 {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cause: Option<String>,
    pub code: f64,
    pub error: String,
    ///Signature of the transaction, if generated
    #[serde(skip_serializing_if = "Option::is_none")]
    pub signature: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub status: Option<PostTriggerV1CreateOrderResponse400Status>,
}
#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize, Default)]
pub enum PostTriggerV1CreateOrderResponse400Status {
    #[default]
    #[serde(rename = "Failed")]
    Failed,
}
impl PostTriggerV1CreateOrderResponse400Status {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::Failed => "Failed",
        }
    }
}
impl ::std::fmt::Display for PostTriggerV1CreateOrderResponse400Status {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        f.write_str(self.as_str())
    }
}
impl AsRef<str> for PostTriggerV1CreateOrderResponse400Status {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PostTriggerV1CreateOrderRequest {
    /**In microlamports, defaults to 95th percentile of priority fees
     */
    #[serde(rename = "computeUnitPrice", skip_serializing_if = "Option::is_none")]
    pub compute_unit_price: Option<String>,
    /**- A token account (via the Referral Program) that will receive the fees
    - Refer to [Referral Program Github](https://github.com/TeamRaccoons/referral/tree/main) for more information
    */
    #[serde(rename = "feeAccount", skip_serializing_if = "Option::is_none")]
    pub fee_account: Option<String>,
    #[serde(rename = "inputMint", default)]
    pub input_mint: String,
    #[serde(default)]
    pub maker: String,
    #[serde(rename = "outputMint", default)]
    pub output_mint: String,
    pub params: PostTriggerV1CreateOrderRequestParams,
    #[serde(default)]
    pub payer: String,
    ///If either input or output mint is native SOL
    #[serde(rename = "wrapAndUnwrapSol", skip_serializing_if = "Option::is_none")]
    pub wrap_and_unwrap_sol: Option<bool>,
}
impl PostTriggerV1CreateOrderRequest {
    /// Construct this request with every required wire field.
    pub fn new(
        input_mint: String,
        maker: String,
        output_mint: String,
        params: PostTriggerV1CreateOrderRequestParams,
        payer: String,
    ) -> Self {
        Self {
            input_mint,
            maker,
            output_mint,
            params,
            payer,
            compute_unit_price: None,
            fee_account: None,
            wrap_and_unwrap_sol: None,
        }
    }
    /// Start a dependency-free builder with every required wire field.
    pub fn builder(
        input_mint: String,
        maker: String,
        output_mint: String,
        params: PostTriggerV1CreateOrderRequestParams,
        payer: String,
    ) -> PostTriggerV1CreateOrderRequestBuilder {
        PostTriggerV1CreateOrderRequestBuilder::new(input_mint, maker, output_mint, params, payer)
    }
}
/// Dependency-free builder for [`#struct_name`].
#[derive(Debug, Clone)]
#[must_use]
pub struct PostTriggerV1CreateOrderRequestBuilder {
    value: PostTriggerV1CreateOrderRequest,
}
impl PostTriggerV1CreateOrderRequestBuilder {
    /// Start a builder with every required wire field.
    pub fn new(
        input_mint: String,
        maker: String,
        output_mint: String,
        params: PostTriggerV1CreateOrderRequestParams,
        payer: String,
    ) -> Self {
        Self {
            value: PostTriggerV1CreateOrderRequest::new(
                input_mint,
                maker,
                output_mint,
                params,
                payer,
            ),
        }
    }
    #[doc = concat!("Set the optional `", "computeUnitPrice", "` request field.")]
    #[must_use]
    pub fn compute_unit_price(mut self, compute_unit_price: String) -> Self {
        self.value.compute_unit_price = Some(compute_unit_price);
        self
    }
    #[doc = concat!("Set the optional `", "feeAccount", "` request field.")]
    #[must_use]
    pub fn fee_account(mut self, fee_account: String) -> Self {
        self.value.fee_account = Some(fee_account);
        self
    }
    #[doc = concat!("Set the optional `", "wrapAndUnwrapSol", "` request field.")]
    #[must_use]
    pub fn wrap_and_unwrap_sol(mut self, wrap_and_unwrap_sol: bool) -> Self {
        self.value.wrap_and_unwrap_sol = Some(wrap_and_unwrap_sol);
        self
    }
    /// Finish building the request model.
    pub fn build(self) -> PostTriggerV1CreateOrderRequest {
        self.value
    }
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PostTriggerV1CreateOrderRequestParams {
    #[serde(rename = "expiredAt", skip_serializing_if = "Option::is_none")]
    pub expired_at: Option<String>,
    /**Requires the `feeAccount` parameter, the amount of fees in bps that will be sent to the fee account
     */
    #[serde(rename = "feeBps", skip_serializing_if = "Option::is_none")]
    pub fee_bps: Option<String>,
    ///Amount of input mint to swap
    #[serde(rename = "makingAmount", default)]
    pub making_amount: String,
    /**Amount of slippage the order can be executed with
     */
    #[serde(rename = "slippageBps", skip_serializing_if = "Option::is_none")]
    pub slippage_bps: Option<String>,
    ///Amount of output mint to receive
    #[serde(rename = "takingAmount", default)]
    pub taking_amount: String,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PostTriggerV1CancelOrdersResponse500 {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cause: Option<String>,
    pub code: f64,
    pub error: String,
    ///Signature of the transaction, if generated
    #[serde(skip_serializing_if = "Option::is_none")]
    pub signature: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub status: Option<PostTriggerV1CancelOrdersResponse500Status>,
}
#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize, Default)]
pub enum PostTriggerV1CancelOrdersResponse500Status {
    #[default]
    #[serde(rename = "Failed")]
    Failed,
}
impl PostTriggerV1CancelOrdersResponse500Status {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::Failed => "Failed",
        }
    }
}
impl ::std::fmt::Display for PostTriggerV1CancelOrdersResponse500Status {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        f.write_str(self.as_str())
    }
}
impl AsRef<str> for PostTriggerV1CancelOrdersResponse500Status {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PostTriggerV1CancelOrdersResponse400 {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cause: Option<String>,
    pub code: f64,
    pub error: String,
    ///Signature of the transaction, if generated
    #[serde(skip_serializing_if = "Option::is_none")]
    pub signature: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub status: Option<PostTriggerV1CancelOrdersResponse400Status>,
}
#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize, Default)]
pub enum PostTriggerV1CancelOrdersResponse400Status {
    #[default]
    #[serde(rename = "Failed")]
    Failed,
}
impl PostTriggerV1CancelOrdersResponse400Status {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::Failed => "Failed",
        }
    }
}
impl ::std::fmt::Display for PostTriggerV1CancelOrdersResponse400Status {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        f.write_str(self.as_str())
    }
}
impl AsRef<str> for PostTriggerV1CancelOrdersResponse400Status {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PostTriggerV1CancelOrderResponse500 {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cause: Option<String>,
    pub code: f64,
    pub error: String,
    ///Signature of the transaction, if generated
    #[serde(skip_serializing_if = "Option::is_none")]
    pub signature: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub status: Option<PostTriggerV1CancelOrderResponse500Status>,
}
#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize, Default)]
pub enum PostTriggerV1CancelOrderResponse500Status {
    #[default]
    #[serde(rename = "Failed")]
    Failed,
}
impl PostTriggerV1CancelOrderResponse500Status {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::Failed => "Failed",
        }
    }
}
impl ::std::fmt::Display for PostTriggerV1CancelOrderResponse500Status {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        f.write_str(self.as_str())
    }
}
impl AsRef<str> for PostTriggerV1CancelOrderResponse500Status {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PostTriggerV1CancelOrderResponse400 {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cause: Option<String>,
    pub code: f64,
    pub error: String,
    ///Signature of the transaction, if generated
    #[serde(skip_serializing_if = "Option::is_none")]
    pub signature: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub status: Option<PostTriggerV1CancelOrderResponse400Status>,
}
#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize, Default)]
pub enum PostTriggerV1CancelOrderResponse400Status {
    #[default]
    #[serde(rename = "Failed")]
    Failed,
}
impl PostTriggerV1CancelOrderResponse400Status {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::Failed => "Failed",
        }
    }
}
impl ::std::fmt::Display for PostTriggerV1CancelOrderResponse400Status {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        f.write_str(self.as_str())
    }
}
impl AsRef<str> for PostTriggerV1CancelOrderResponse400Status {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct PostStudioV1DbcPoolSubmitResponse {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub data: Option<PostStudioV1DbcPoolSubmitResponseData>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub success: Option<bool>,
}
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct PostStudioV1DbcPoolSubmitResponseData {
    #[serde(rename = "configKey", skip_serializing_if = "Option::is_none")]
    pub config_key: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub mint: Option<String>,
}
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct PostStudioV1DbcFeeResponse400 {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub errors: Option<PostStudioV1DbcFeeResponse400Errors>,
}
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct PostStudioV1DbcFeeResponse400Errors {
    /// Additional properties matching the spec's
    /// `additionalProperties` value schema.
    #[serde(flatten)]
    pub additional_properties: std::collections::BTreeMap<String, Vec<String>>,
}
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct PostStudioV1DbcFeeCreateTxResponse400 {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub errors: Option<PostStudioV1DbcFeeCreateTxResponse400Errors>,
}
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct PostStudioV1DbcFeeCreateTxResponse400Errors {
    /// Additional properties matching the spec's
    /// `additionalProperties` value schema.
    #[serde(flatten)]
    pub additional_properties: std::collections::BTreeMap<String, Vec<String>>,
}
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct PostExecuteResponse {
    /**- Error code. 0 = success.
    - Ultra: -1 (missing cached order), -2 (invalid signed tx), -3 (invalid message bytes).
    - Aggregator: -1000 (failed to land), -1001 (unknown), -1002 (invalid tx), -1003 (not fully signed), -1004 (invalid block height).
    - RFQ: -2000 (failed to land), -2001 (unknown), -2002 (invalid payload), -2003 (quote expired), -2004 (swap rejected).
    */
    #[serde(skip_serializing_if = "Option::is_none")]
    pub code: Option<f64>,
    ///Error message (present if Failed)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub error: Option<String>,
    ///Input amount that went into the swap route, after any fee collected in the input mint
    #[serde(rename = "inputAmountResult", skip_serializing_if = "Option::is_none")]
    pub input_amount_result: Option<String>,
    ///Output amount produced by the swap route, before any fee collected in the output mint
    #[serde(rename = "outputAmountResult", skip_serializing_if = "Option::is_none")]
    pub output_amount_result: Option<String>,
    ///Transaction signature
    #[serde(skip_serializing_if = "Option::is_none")]
    pub signature: Option<String>,
    ///Confirmed slot
    #[serde(skip_serializing_if = "Option::is_none")]
    pub slot: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub status: Option<PostExecuteResponseStatus>,
    #[serde(rename = "swapEvents", skip_serializing_if = "Option::is_none")]
    pub swap_events: Option<Vec<SwapV2SwapEvent>>,
    ///Total input token amount deducted from the user's wallet, including the fee if feeMint is the input mint
    #[serde(rename = "totalInputAmount", skip_serializing_if = "Option::is_none")]
    pub total_input_amount: Option<String>,
    ///Final output token amount reflected in the user's wallet, after any fee collected in the output mint
    #[serde(rename = "totalOutputAmount", skip_serializing_if = "Option::is_none")]
    pub total_output_amount: Option<String>,
}
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct SwapV2SwapEvent {
    #[serde(rename = "inputAmount", skip_serializing_if = "Option::is_none")]
    pub input_amount: Option<String>,
    #[serde(rename = "inputMint", skip_serializing_if = "Option::is_none")]
    pub input_mint: Option<String>,
    #[serde(rename = "outputAmount", skip_serializing_if = "Option::is_none")]
    pub output_amount: Option<String>,
    #[serde(rename = "outputMint", skip_serializing_if = "Option::is_none")]
    pub output_mint: Option<String>,
}
#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize, Default)]
pub enum PostExecuteResponseStatus {
    #[default]
    #[serde(rename = "Success")]
    Success,
    #[serde(rename = "Failed")]
    Failed,
}
impl PostExecuteResponseStatus {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::Success => "Success",
            Self::Failed => "Failed",
        }
    }
}
impl ::std::fmt::Display for PostExecuteResponseStatus {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        f.write_str(self.as_str())
    }
}
impl AsRef<str> for PostExecuteResponseStatus {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PatchTriggerV2OrdersPriceOrderIdRequest {
    #[serde(rename = "orderType")]
    pub order_type: PatchTriggerV2OrdersPriceOrderIdRequestOrderType,
    #[serde(rename = "slPriceUsd", skip_serializing_if = "Option::is_none")]
    pub sl_price_usd: Option<f64>,
    #[serde(rename = "slSlippageBps", skip_serializing_if = "Option::is_none")]
    pub sl_slippage_bps: Option<f64>,
    #[serde(rename = "slippageBps", skip_serializing_if = "Option::is_none")]
    pub slippage_bps: Option<f64>,
    #[serde(rename = "tpPriceUsd", skip_serializing_if = "Option::is_none")]
    pub tp_price_usd: Option<f64>,
    #[serde(rename = "tpSlippageBps", skip_serializing_if = "Option::is_none")]
    pub tp_slippage_bps: Option<f64>,
    ///New trailing stop loss trail distance in basis points (50-9000), for an order that is already trailing.
    ///Constraint: minimum=50, maximum=9000
    #[serde(rename = "trailingBps", skip_serializing_if = "Option::is_none")]
    pub trailing_bps: Option<f64>,
    ///New trigger price. Cannot be set on a trailing stop loss order.
    #[serde(rename = "triggerPriceUsd", skip_serializing_if = "Option::is_none")]
    pub trigger_price_usd: Option<f64>,
}
impl PatchTriggerV2OrdersPriceOrderIdRequest {
    /// Construct this request with every required wire field.
    pub fn new(order_type: PatchTriggerV2OrdersPriceOrderIdRequestOrderType) -> Self {
        Self {
            order_type,
            sl_price_usd: None,
            sl_slippage_bps: None,
            slippage_bps: None,
            tp_price_usd: None,
            tp_slippage_bps: None,
            trailing_bps: None,
            trigger_price_usd: None,
        }
    }
    /// Start a dependency-free builder with every required wire field.
    pub fn builder(
        order_type: PatchTriggerV2OrdersPriceOrderIdRequestOrderType,
    ) -> PatchTriggerV2OrdersPriceOrderIdRequestBuilder {
        PatchTriggerV2OrdersPriceOrderIdRequestBuilder::new(order_type)
    }
}
/// Dependency-free builder for [`#struct_name`].
#[derive(Debug, Clone)]
#[must_use]
pub struct PatchTriggerV2OrdersPriceOrderIdRequestBuilder {
    value: PatchTriggerV2OrdersPriceOrderIdRequest,
}
impl PatchTriggerV2OrdersPriceOrderIdRequestBuilder {
    /// Start a builder with every required wire field.
    pub fn new(order_type: PatchTriggerV2OrdersPriceOrderIdRequestOrderType) -> Self {
        Self {
            value: PatchTriggerV2OrdersPriceOrderIdRequest::new(order_type),
        }
    }
    #[doc = concat!("Set the optional `", "slPriceUsd", "` request field.")]
    #[must_use]
    pub fn sl_price_usd(mut self, sl_price_usd: f64) -> Self {
        self.value.sl_price_usd = Some(sl_price_usd);
        self
    }
    #[doc = concat!("Set the optional `", "slSlippageBps", "` request field.")]
    #[must_use]
    pub fn sl_slippage_bps(mut self, sl_slippage_bps: f64) -> Self {
        self.value.sl_slippage_bps = Some(sl_slippage_bps);
        self
    }
    #[doc = concat!("Set the optional `", "slippageBps", "` request field.")]
    #[must_use]
    pub fn slippage_bps(mut self, slippage_bps: f64) -> Self {
        self.value.slippage_bps = Some(slippage_bps);
        self
    }
    #[doc = concat!("Set the optional `", "tpPriceUsd", "` request field.")]
    #[must_use]
    pub fn tp_price_usd(mut self, tp_price_usd: f64) -> Self {
        self.value.tp_price_usd = Some(tp_price_usd);
        self
    }
    #[doc = concat!("Set the optional `", "tpSlippageBps", "` request field.")]
    #[must_use]
    pub fn tp_slippage_bps(mut self, tp_slippage_bps: f64) -> Self {
        self.value.tp_slippage_bps = Some(tp_slippage_bps);
        self
    }
    #[doc = concat!("Set the optional `", "trailingBps", "` request field.")]
    #[must_use]
    pub fn trailing_bps(mut self, trailing_bps: f64) -> Self {
        self.value.trailing_bps = Some(trailing_bps);
        self
    }
    #[doc = concat!("Set the optional `", "triggerPriceUsd", "` request field.")]
    #[must_use]
    pub fn trigger_price_usd(mut self, trigger_price_usd: f64) -> Self {
        self.value.trigger_price_usd = Some(trigger_price_usd);
        self
    }
    /// Finish building the request model.
    pub fn build(self) -> PatchTriggerV2OrdersPriceOrderIdRequest {
        self.value
    }
}
#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize, Default)]
pub enum PatchTriggerV2OrdersPriceOrderIdRequestOrderType {
    #[default]
    #[serde(rename = "single")]
    Single,
    #[serde(rename = "oco")]
    Oco,
    #[serde(rename = "otoco")]
    Otoco,
}
impl PatchTriggerV2OrdersPriceOrderIdRequestOrderType {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::Single => "single",
            Self::Oco => "oco",
            Self::Otoco => "otoco",
        }
    }
}
impl ::std::fmt::Display for PatchTriggerV2OrdersPriceOrderIdRequestOrderType {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        f.write_str(self.as_str())
    }
}
impl AsRef<str> for PatchTriggerV2OrdersPriceOrderIdRequestOrderType {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}
pub type ListBorrowVaultsResponse = Vec<LendBorrowBorrowVault>;
pub type ListBorrowPositionsResponse = Vec<LendBorrowBorrowPosition>;
pub type LendUserPositionsResponse = Vec<LendUserPosition>;
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct LendUserPosition {
    pub allowance: String,
    /**- Address of user's wallet
     */
    #[serde(rename = "ownerAddress")]
    pub owner_address: String,
    /**- Balance of user's jlTokens
     */
    pub shares: String,
    pub token: LendTokenInfo,
    /**- Balance of user's USDC in protocol (including intereste accured)
     */
    #[serde(rename = "underlyingAssets")]
    pub underlying_assets: String,
    /**- Balance of user's USDC in wallet
     */
    #[serde(rename = "underlyingBalance")]
    pub underlying_balance: String,
}
pub type LendTokensResponse = Vec<LendTokenInfo>;
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct LendTokenInfo {
    /**- Lending token address like `9BEcn9aPEmhSPbPQeFGjidRiEKki46fVQDyPpSQXPA2D`
     */
    pub address: String,
    pub asset: LendAssetInfo,
    /**- Lending token underlying asset address like `EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v`
     */
    #[serde(rename = "assetAddress")]
    pub asset_address: String,
    /**- Value of one 1 jlToken token to underlying mint, like 1 jlUSDC = X USDC
    - Used for conversion
    */
    #[serde(rename = "convertToAssets")]
    pub convert_to_assets: String,
    /**- Value of one 1 underlying token to jlToken, like 1 USDC = X jlUSDC
    - Used for conversion
    */
    #[serde(rename = "convertToShares")]
    pub convert_to_shares: String,
    pub decimals: i64,
    /**- Lending ID, starts from `1`
     */
    pub id: i64,
    #[serde(rename = "liquiditySupplyData")]
    pub liquidity_supply_data: LendLiquiditySupplyData,
    /**- Lending token name like Jupiter Lend USDC
     */
    pub name: String,
    #[serde(rename = "rebalanceDifference")]
    pub rebalance_difference: String,
    /**- Rewards rate , in 1e4 decimals
     */
    #[serde(rename = "rewardsRate")]
    pub rewards_rate: String,
    /**- Supply rate, in 1e4 decimals
     */
    #[serde(rename = "supplyRate")]
    pub supply_rate: String,
    /**- Lending token symbol like jlUSDC
     */
    pub symbol: String,
    /**- Total available underlying mint from jlTokens (with accured interest)
     */
    #[serde(rename = "totalAssets")]
    pub total_assets: String,
    /**- Total sum of rewards + supply rate
     */
    #[serde(rename = "totalRate")]
    pub total_rate: String,
    /**- Total supply of jlTokens for this mint
     */
    #[serde(rename = "totalSupply")]
    pub total_supply: String,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct LendLiquiditySupplyData {
    #[serde(rename = "baseWithdrawalLimit")]
    pub base_withdrawal_limit: String,
    #[serde(rename = "expandDuration")]
    pub expand_duration: String,
    #[serde(rename = "expandPercent")]
    pub expand_percent: String,
    /**- When was the reserve last updated
     */
    #[serde(rename = "lastUpdateTimestamp")]
    pub last_update_timestamp: String,
    /**- The underlying asset is earning interest at liquidity layer
     */
    #[serde(rename = "modeWithInterest")]
    pub mode_with_interest: bool,
    /**- Total supply of underlying asset on liquidity layer
    - In decimals, like 3168044480191 / 1e6 for USDC
    */
    pub supply: String,
    /**- Total amount withdrawable at this current point, it expands every second.
     */
    pub withdrawable: String,
    #[serde(rename = "withdrawableUntilLimit")]
    pub withdrawable_until_limit: String,
    /**- Available withdrawal limit for this asset
     */
    #[serde(rename = "withdrawalLimit")]
    pub withdrawal_limit: String,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct LendAssetInfo {
    /**- Lending token underlying asset address like `EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v`
     */
    pub address: String,
    /**- Lending token underlying asset chain id like `solana`
     */
    pub chain_id: String,
    pub coingecko_id: String,
    pub decimals: i64,
    pub logo_url: url::Url,
    pub name: String,
    pub price: String,
    pub symbol: String,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct LendInstructionResponse {
    pub accounts: Vec<LendAccountMeta>,
    pub data: String,
    #[serde(rename = "programId")]
    pub program_id: String,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct LendAccountMeta {
    #[serde(rename = "isSigner")]
    pub is_signer: bool,
    #[serde(rename = "isWritable")]
    pub is_writable: bool,
    pub pubkey: String,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct LendBorrowOperateInstructionsResponse {
    #[serde(rename = "addressLookupTableAddresses")]
    pub address_lookup_table_addresses: Vec<String>,
    pub instructions: Vec<LendBorrowSolanaInstruction>,
    #[serde(rename = "nftId")]
    pub nft_id: i64,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct LendBorrowSolanaInstruction {
    pub accounts: Vec<LendBorrowSolanaAccountMeta>,
    ///Base64-encoded instruction data.
    pub data: String,
    #[serde(rename = "programId")]
    pub program_id: String,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct LendBorrowSolanaAccountMeta {
    #[serde(rename = "isSigner")]
    pub is_signer: bool,
    #[serde(rename = "isWritable")]
    pub is_writable: bool,
    pub pubkey: String,
}
///Serialized position data from `getVaultPositionsByUser()` in `app/core/borrowing.ts`.
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct LendBorrowBorrowPosition {
    ///Position NFT mint address.
    pub address: String,
    #[serde(rename = "beforeBorrow")]
    pub before_borrow: String,
    #[serde(rename = "beforeSupply")]
    pub before_supply: String,
    pub borrow: String,
    #[serde(rename = "borrowLiquidation")]
    pub borrow_liquidation: String,
    ///Key/value position config from the database, keyed in camelCase.
    pub config: LendBorrowBorrowPositionConfig,
    #[serde(rename = "dustBorrow")]
    pub dust_borrow: String,
    ///NFT / position id.
    pub id: i64,
    #[serde(rename = "isLiquidated")]
    pub is_liquidated: bool,
    #[serde(rename = "isSupplyPosition")]
    pub is_supply_position: bool,
    #[serde(rename = "ownerAddress")]
    pub owner_address: String,
    pub supply: String,
    #[serde(rename = "supplyLiquidation")]
    pub supply_liquidation: String,
    pub tick: i64,
    #[serde(rename = "tickId")]
    pub tick_id: i64,
    pub vault: LendBorrowBorrowVault,
    #[serde(rename = "vaultId")]
    pub vault_id: i64,
}
///Serialized vault data from `serializedVault()` in `app/core/borrowing.ts`.
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct LendBorrowBorrowVault {
    #[serde(rename = "absorbedBorrow", skip_serializing_if = "Option::is_none")]
    pub absorbed_borrow: Option<String>,
    #[serde(rename = "absorbedSupply", skip_serializing_if = "Option::is_none")]
    pub absorbed_supply: Option<String>,
    pub address: String,
    #[serde(rename = "borrowFee", skip_serializing_if = "Option::is_none")]
    pub borrow_fee: Option<String>,
    #[serde(rename = "borrowLimit", skip_serializing_if = "Option::is_none")]
    pub borrow_limit: Option<String>,
    #[serde(
        rename = "borrowLimitUtilization",
        skip_serializing_if = "Option::is_none"
    )]
    pub borrow_limit_utilization: Option<String>,
    #[serde(rename = "borrowRate", skip_serializing_if = "Option::is_none")]
    pub borrow_rate: Option<String>,
    #[serde(
        rename = "borrowRateLiquidity",
        skip_serializing_if = "Option::is_none"
    )]
    pub borrow_rate_liquidity: Option<String>,
    #[serde(
        rename = "borrowRateMagnifier",
        skip_serializing_if = "Option::is_none"
    )]
    pub borrow_rate_magnifier: Option<String>,
    #[serde(rename = "borrowToken")]
    pub borrow_token: LendBorrowToken,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub borrowable: Option<String>,
    #[serde(
        rename = "borrowableUntilLimit",
        skip_serializing_if = "Option::is_none"
    )]
    pub borrowable_until_limit: Option<String>,
    #[serde(rename = "collateralFactor", skip_serializing_if = "Option::is_none")]
    pub collateral_factor: Option<String>,
    pub id: i64,
    #[serde(
        rename = "liquidationMaxLimit",
        skip_serializing_if = "Option::is_none"
    )]
    pub liquidation_max_limit: Option<String>,
    #[serde(rename = "liquidationPenalty", skip_serializing_if = "Option::is_none")]
    pub liquidation_penalty: Option<String>,
    #[serde(
        rename = "liquidationThreshold",
        skip_serializing_if = "Option::is_none"
    )]
    pub liquidation_threshold: Option<String>,
    #[serde(
        rename = "liquidityBorrowData",
        skip_serializing_if = "Option::is_none"
    )]
    pub liquidity_borrow_data: Option<LendBorrowLiquidityBorrowData>,
    #[serde(
        rename = "liquiditySupplyData",
        skip_serializing_if = "Option::is_none"
    )]
    pub liquidity_supply_data: Option<LendBorrowLiquiditySupplyData>,
    pub metadata: LendBorrowVaultMetadata,
    #[serde(rename = "minimumBorrowing", skip_serializing_if = "Option::is_none")]
    pub minimum_borrowing: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub oracle: Option<String>,
    #[serde(rename = "oraclePrice", skip_serializing_if = "Option::is_none")]
    pub oracle_price: Option<String>,
    #[serde(
        rename = "oraclePriceLiquidate",
        skip_serializing_if = "Option::is_none"
    )]
    pub oracle_price_liquidate: Option<String>,
    #[serde(rename = "oraclePriceOperate", skip_serializing_if = "Option::is_none")]
    pub oracle_price_operate: Option<String>,
    #[serde(rename = "oracleSources", skip_serializing_if = "Option::is_none")]
    pub oracle_sources: Option<Vec<LendBorrowOracleSource>>,
    #[serde(rename = "oracleTimestamp", skip_serializing_if = "Option::is_none")]
    pub oracle_timestamp: Option<i64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub rewards: Option<Vec<LendBorrowMarketReward>>,
    #[serde(rename = "supplyRate", skip_serializing_if = "Option::is_none")]
    pub supply_rate: Option<String>,
    #[serde(
        rename = "supplyRateLiquidity",
        skip_serializing_if = "Option::is_none"
    )]
    pub supply_rate_liquidity: Option<String>,
    #[serde(
        rename = "supplyRateMagnifier",
        skip_serializing_if = "Option::is_none"
    )]
    pub supply_rate_magnifier: Option<String>,
    #[serde(rename = "supplyToken")]
    pub supply_token: LendBorrowToken,
    #[serde(rename = "topTick", skip_serializing_if = "Option::is_none")]
    pub top_tick: Option<i64>,
    #[serde(rename = "totalBorrow", skip_serializing_if = "Option::is_none")]
    pub total_borrow: Option<String>,
    #[serde(
        rename = "totalBorrowLiquidity",
        skip_serializing_if = "Option::is_none"
    )]
    pub total_borrow_liquidity: Option<String>,
    #[serde(rename = "totalPositions", skip_serializing_if = "Option::is_none")]
    pub total_positions: Option<i64>,
    #[serde(rename = "totalSupply", skip_serializing_if = "Option::is_none")]
    pub total_supply: Option<String>,
    #[serde(
        rename = "totalSupplyLiquidity",
        skip_serializing_if = "Option::is_none"
    )]
    pub total_supply_liquidity: Option<String>,
    #[serde(rename = "withdrawLimit", skip_serializing_if = "Option::is_none")]
    pub withdraw_limit: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub withdrawable: Option<String>,
    #[serde(
        rename = "withdrawableUntilLimit",
        skip_serializing_if = "Option::is_none"
    )]
    pub withdrawable_until_limit: Option<String>,
    #[serde(rename = "withdrawalGap", skip_serializing_if = "Option::is_none")]
    pub withdrawal_gap: Option<String>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct LendBorrowVaultMetadata {
    #[serde(rename = "maxLeverage")]
    pub max_leverage: bool,
    pub multiply: LendBorrowVaultMetadataMultiply,
    #[serde(rename = "nativeStake")]
    pub native_stake: bool,
    pub pegged: bool,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct LendBorrowVaultMetadataMultiply {
    pub enabled: bool,
    #[serde(rename = "reduceFactor")]
    pub reduce_factor: i64,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct LendBorrowOracleSource {
    pub divisor: String,
    pub invert: bool,
    pub multiplier: String,
    pub source: String,
    #[serde(rename = "sourceType")]
    pub source_type: LendBorrowOracleSourceSourceType,
}
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct LendBorrowOracleSourceSourceType {
    /// Additional properties not explicitly defined in the schema
    #[serde(flatten)]
    pub additional_properties: std::collections::BTreeMap<String, serde_json::Value>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct LendBorrowMarketReward {
    pub apr: String,
    pub metadata: LendBorrowMarketRewardMetadata,
    #[serde(rename = "rewardToken")]
    pub reward_token: LendBorrowToken,
    pub side: LendBorrowMarketRewardSide,
    pub r#type: LendBorrowMarketRewardType,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct LendBorrowToken {
    ///SPL token mint address.
    pub address: String,
    #[serde(rename = "chainId")]
    pub chain_id: String,
    #[serde(rename = "coingeckoId", skip_serializing_if = "Option::is_none")]
    pub coingecko_id: Option<String>,
    pub decimals: i64,
    #[serde(rename = "logoUrl", skip_serializing_if = "Option::is_none")]
    pub logo_url: Option<url::Url>,
    pub name: String,
    ///Present on native-stake collateral tokens when applicable.
    #[serde(
        rename = "nativeStakeVoteAccount",
        skip_serializing_if = "Option::is_none"
    )]
    pub native_stake_vote_account: Option<String>,
    ///Token price as a decimal string.
    pub price: String,
    ///Token-2022 scaled-UI-amount config. Present on scaled-UI tokens (e.g. tokenised stocks).
    #[serde(rename = "scaledUiConfig", skip_serializing_if = "Option::is_none")]
    pub scaled_ui_config: Option<LendBorrowTokenScaledUiConfig>,
    ///Present on vault supply/borrow tokens when applicable.
    #[serde(rename = "stakingApr", skip_serializing_if = "Option::is_none")]
    pub staking_apr: Option<f64>,
    pub symbol: String,
    #[serde(rename = "uiSymbol")]
    pub ui_symbol: String,
    #[serde(rename = "updatedAt", skip_serializing_if = "Option::is_none")]
    pub updated_at: Option<chrono::DateTime<chrono::Utc>>,
}
///Token-2022 scaled-UI-amount config. Present on scaled-UI tokens (e.g. tokenised stocks).
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct LendBorrowTokenScaledUiConfig {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub authority: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub multiplier: Option<f64>,
    #[serde(rename = "newMultiplier", skip_serializing_if = "Option::is_none")]
    pub new_multiplier: Option<f64>,
    #[serde(
        rename = "newMultiplierEffectiveTimestamp",
        skip_serializing_if = "Option::is_none"
    )]
    pub new_multiplier_effective_timestamp: Option<String>,
}
#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize, Default)]
pub enum LendBorrowMarketRewardType {
    #[default]
    #[serde(rename = "merkle")]
    Merkle,
}
impl LendBorrowMarketRewardType {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::Merkle => "merkle",
        }
    }
}
impl ::std::fmt::Display for LendBorrowMarketRewardType {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        f.write_str(self.as_str())
    }
}
impl AsRef<str> for LendBorrowMarketRewardType {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}
#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize, Default)]
pub enum LendBorrowMarketRewardSide {
    #[default]
    #[serde(rename = "supply")]
    Supply,
    #[serde(rename = "borrow")]
    Borrow,
}
impl LendBorrowMarketRewardSide {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::Supply => "supply",
            Self::Borrow => "borrow",
        }
    }
}
impl ::std::fmt::Display for LendBorrowMarketRewardSide {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        f.write_str(self.as_str())
    }
}
impl AsRef<str> for LendBorrowMarketRewardSide {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct LendBorrowMarketRewardMetadata {
    /// Additional properties not explicitly defined in the schema
    #[serde(flatten)]
    pub additional_properties: std::collections::BTreeMap<String, serde_json::Value>,
}
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct LendBorrowLiquiditySupplyData {
    #[serde(
        rename = "baseWithdrawalLimit",
        skip_serializing_if = "Option::is_none"
    )]
    pub base_withdrawal_limit: Option<String>,
    #[serde(rename = "expandDuration", skip_serializing_if = "Option::is_none")]
    pub expand_duration: Option<LendBorrowLiquiditySupplyDataExpandDuration>,
    #[serde(rename = "expandPercent", skip_serializing_if = "Option::is_none")]
    pub expand_percent: Option<i64>,
    #[serde(
        rename = "lastUpdateTimestamp",
        skip_serializing_if = "Option::is_none"
    )]
    pub last_update_timestamp: Option<String>,
    #[serde(rename = "modeWithInterest", skip_serializing_if = "Option::is_none")]
    pub mode_with_interest: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub supply: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub withdrawable: Option<String>,
    #[serde(
        rename = "withdrawableUntilLimit",
        skip_serializing_if = "Option::is_none"
    )]
    pub withdrawable_until_limit: Option<String>,
    #[serde(rename = "withdrawalLimit", skip_serializing_if = "Option::is_none")]
    pub withdrawal_limit: Option<String>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
pub enum LendBorrowLiquiditySupplyDataExpandDuration {
    String(String),
    Integer(i64),
}
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct LendBorrowLiquidityBorrowData {
    #[serde(rename = "baseBorrowLimit", skip_serializing_if = "Option::is_none")]
    pub base_borrow_limit: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub borrow: Option<String>,
    #[serde(rename = "borrowLimit", skip_serializing_if = "Option::is_none")]
    pub borrow_limit: Option<String>,
    #[serde(
        rename = "borrowLimitUtilization",
        skip_serializing_if = "Option::is_none"
    )]
    pub borrow_limit_utilization: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub borrowable: Option<String>,
    #[serde(
        rename = "borrowableUntilLimit",
        skip_serializing_if = "Option::is_none"
    )]
    pub borrowable_until_limit: Option<String>,
    #[serde(rename = "expandDuration", skip_serializing_if = "Option::is_none")]
    pub expand_duration: Option<i64>,
    #[serde(rename = "expandPercent", skip_serializing_if = "Option::is_none")]
    pub expand_percent: Option<i64>,
    #[serde(
        rename = "lastUpdateTimestamp",
        skip_serializing_if = "Option::is_none"
    )]
    pub last_update_timestamp: Option<LendBorrowLiquidityBorrowDataLastUpdateTimestamp>,
    #[serde(rename = "maxBorrowLimit", skip_serializing_if = "Option::is_none")]
    pub max_borrow_limit: Option<String>,
    #[serde(rename = "modeWithInterest", skip_serializing_if = "Option::is_none")]
    pub mode_with_interest: Option<bool>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
pub enum LendBorrowLiquidityBorrowDataLastUpdateTimestamp {
    String(String),
    Integer(i64),
}
///Key/value position config from the database, keyed in camelCase.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct LendBorrowBorrowPositionConfig {
    /// Additional properties matching the spec's
    /// `additionalProperties` value schema.
    #[serde(flatten)]
    pub additional_properties: std::collections::BTreeMap<String, String>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct GetUltraV1ShieldResponse {
    pub warnings: GetUltraV1ShieldResponseWarnings,
}
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct GetUltraV1ShieldResponseWarnings {
    /// Additional properties matching the spec's
    /// `additionalProperties` value schema.
    #[serde(flatten)]
    pub additional_properties: std::collections::BTreeMap<String, Vec<ArrayItemItem>>,
}
pub type GetUltraV1SearchResponse = Vec<UltraMintInformation>;
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct UltraMintInformation {
    ///APY data, only present for assets listed on Jupiter Lend's Earn
    #[serde(skip_serializing_if = "Option::is_none")]
    pub apy: Option<UltraMintInformationApy>,
    /**Audit information. All sub-fields are conditional and vary per token.
     */
    #[serde(skip_serializing_if = "Option::is_none")]
    pub audit: Option<UltraMintInformationAudit>,
    #[serde(rename = "circSupply", skip_serializing_if = "Option::is_none")]
    pub circ_supply: Option<f64>,
    ///Token creation timestamp
    #[serde(rename = "createdAt", skip_serializing_if = "Option::is_none")]
    pub created_at: Option<chrono::DateTime<chrono::Utc>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub decimals: Option<f64>,
    ///The token's developer wallet address
    #[serde(skip_serializing_if = "Option::is_none")]
    pub dev: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub discord: Option<String>,
    ///Fully diluted valuation in USD
    #[serde(skip_serializing_if = "Option::is_none")]
    pub fdv: Option<f64>,
    ///Trading fees in USD
    #[serde(skip_serializing_if = "Option::is_none")]
    pub fees: Option<f64>,
    #[serde(rename = "firstPool", skip_serializing_if = "Option::is_none")]
    pub first_pool: Option<UltraMintInformationFirstPool>,
    ///Freeze authority address (present when freeze authority is not disabled)
    #[serde(rename = "freezeAuthority", skip_serializing_if = "Option::is_none")]
    pub freeze_authority: Option<String>,
    #[serde(rename = "graduatedAt", skip_serializing_if = "Option::is_none")]
    pub graduated_at: Option<String>,
    #[serde(rename = "graduatedPool", skip_serializing_if = "Option::is_none")]
    pub graduated_pool: Option<String>,
    #[serde(rename = "holderCount", skip_serializing_if = "Option::is_none")]
    pub holder_count: Option<f64>,
    ///URL to the token's logo image
    #[serde(skip_serializing_if = "Option::is_none")]
    pub icon: Option<String>,
    ///The token's mint address
    #[serde(skip_serializing_if = "Option::is_none")]
    pub id: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub instagram: Option<String>,
    #[serde(rename = "isVerified", skip_serializing_if = "Option::is_none")]
    pub is_verified: Option<bool>,
    ///Token issuer name (e.g., "Circle" for USDC)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub issuer: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub launchpad: Option<String>,
    ///Total liquidity in USD
    #[serde(skip_serializing_if = "Option::is_none")]
    pub liquidity: Option<f64>,
    ///Market cap in USD
    #[serde(skip_serializing_if = "Option::is_none")]
    pub mcap: Option<f64>,
    ///Mint authority address (present when mint authority is not disabled)
    #[serde(rename = "mintAuthority", skip_serializing_if = "Option::is_none")]
    pub mint_authority: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    ///Organic trading activity score (0-100)
    #[serde(rename = "organicScore", skip_serializing_if = "Option::is_none")]
    pub organic_score: Option<f64>,
    #[serde(rename = "organicScoreLabel", skip_serializing_if = "Option::is_none")]
    pub organic_score_label: Option<UltraMintInformationOrganicScoreLabel>,
    #[serde(rename = "otherUrl", skip_serializing_if = "Option::is_none")]
    pub other_url: Option<String>,
    #[serde(rename = "partnerConfig", skip_serializing_if = "Option::is_none")]
    pub partner_config: Option<String>,
    ///Solana block number for the price data point
    #[serde(rename = "priceBlockId", skip_serializing_if = "Option::is_none")]
    pub price_block_id: Option<f64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub stats1h: Option<UltraSwapStats>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub stats24h: Option<UltraSwapStats>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub stats30d: Option<UltraSwapStats>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub stats5m: Option<UltraSwapStats>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub stats6h: Option<UltraSwapStats>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub stats7d: Option<UltraSwapStats>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub symbol: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tags: Option<Vec<String>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub telegram: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tiktok: Option<String>,
    ///The token program address (SPL Token or Token-2022)
    #[serde(rename = "tokenProgram", skip_serializing_if = "Option::is_none")]
    pub token_program: Option<String>,
    #[serde(rename = "totalSupply", skip_serializing_if = "Option::is_none")]
    pub total_supply: Option<f64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub twitter: Option<String>,
    ///Last data update timestamp
    #[serde(rename = "updatedAt", skip_serializing_if = "Option::is_none")]
    pub updated_at: Option<chrono::DateTime<chrono::Utc>>,
    #[serde(rename = "usdPrice", skip_serializing_if = "Option::is_none")]
    pub usd_price: Option<f64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub website: Option<String>,
}
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct UltraSwapStats {
    #[serde(rename = "buyOrganicVolume", skip_serializing_if = "Option::is_none")]
    pub buy_organic_volume: Option<f64>,
    #[serde(rename = "buyVolume", skip_serializing_if = "Option::is_none")]
    pub buy_volume: Option<f64>,
    #[serde(rename = "holderChange", skip_serializing_if = "Option::is_none")]
    pub holder_change: Option<f64>,
    #[serde(rename = "liquidityChange", skip_serializing_if = "Option::is_none")]
    pub liquidity_change: Option<f64>,
    #[serde(rename = "numBuys", skip_serializing_if = "Option::is_none")]
    pub num_buys: Option<f64>,
    #[serde(rename = "numNetBuyers", skip_serializing_if = "Option::is_none")]
    pub num_net_buyers: Option<f64>,
    #[serde(rename = "numOrganicBuyers", skip_serializing_if = "Option::is_none")]
    pub num_organic_buyers: Option<f64>,
    #[serde(rename = "numSells", skip_serializing_if = "Option::is_none")]
    pub num_sells: Option<f64>,
    #[serde(rename = "numTraders", skip_serializing_if = "Option::is_none")]
    pub num_traders: Option<f64>,
    #[serde(rename = "priceChange", skip_serializing_if = "Option::is_none")]
    pub price_change: Option<f64>,
    #[serde(rename = "sellOrganicVolume", skip_serializing_if = "Option::is_none")]
    pub sell_organic_volume: Option<f64>,
    #[serde(rename = "sellVolume", skip_serializing_if = "Option::is_none")]
    pub sell_volume: Option<f64>,
    #[serde(rename = "volumeChange", skip_serializing_if = "Option::is_none")]
    pub volume_change: Option<f64>,
}
#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize, Default)]
pub enum UltraMintInformationOrganicScoreLabel {
    #[default]
    #[serde(rename = "high")]
    High,
    #[serde(rename = "medium")]
    Medium,
    #[serde(rename = "low")]
    Low,
}
impl UltraMintInformationOrganicScoreLabel {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::High => "high",
            Self::Medium => "medium",
            Self::Low => "low",
        }
    }
}
impl ::std::fmt::Display for UltraMintInformationOrganicScoreLabel {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        f.write_str(self.as_str())
    }
}
impl AsRef<str> for UltraMintInformationOrganicScoreLabel {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct UltraMintInformationFirstPool {
    ///Pool creation timestamp
    #[serde(rename = "createdAt", skip_serializing_if = "Option::is_none")]
    pub created_at: Option<String>,
    ///Pool address
    #[serde(skip_serializing_if = "Option::is_none")]
    pub id: Option<String>,
}
/**Audit information. All sub-fields are conditional and vary per token.
*/
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct UltraMintInformationAudit {
    ///Percentage of supply held by the developer
    #[serde(
        rename = "devBalancePercentage",
        skip_serializing_if = "Option::is_none"
    )]
    pub dev_balance_percentage: Option<f64>,
    ///Number of developer mint events
    #[serde(rename = "devMints", skip_serializing_if = "Option::is_none")]
    pub dev_mints: Option<f64>,
    #[serde(
        rename = "freezeAuthorityDisabled",
        skip_serializing_if = "Option::is_none"
    )]
    pub freeze_authority_disabled: Option<bool>,
    /**Flagged as suspicious. This field is only present when the token
    has been flagged — check for the field's presence, not its value.
    Not all risky tokens will have this flag.
    */
    #[serde(rename = "isSus", skip_serializing_if = "Option::is_none")]
    pub is_sus: Option<bool>,
    #[serde(
        rename = "mintAuthorityDisabled",
        skip_serializing_if = "Option::is_none"
    )]
    pub mint_authority_disabled: Option<bool>,
    ///Percentage of supply held by top holders
    #[serde(
        rename = "topHoldersPercentage",
        skip_serializing_if = "Option::is_none"
    )]
    pub top_holders_percentage: Option<f64>,
}
///APY data, only present for assets listed on Jupiter Lend's Earn
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct UltraMintInformationApy {
    ///Annual percentage yield from Jupiter Earn
    #[serde(rename = "jupEarn", skip_serializing_if = "Option::is_none")]
    pub jup_earn: Option<f64>,
}
pub type GetUltraV1OrderRoutersResponse = Vec<GetUltraV1OrderRoutersResponseItem>;
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct GetUltraV1OrderRoutersResponseItem {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub icon: Option<String>,
    pub id: String,
    pub name: GetUltraV1OrderRoutersResponseName,
}
#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize, Default)]
pub enum GetUltraV1OrderRoutersResponseName {
    #[default]
    #[serde(rename = "Metis")]
    Metis,
    #[serde(rename = "JupiterZ")]
    JupiterZ,
    #[serde(rename = "DFlow")]
    Dflow,
    #[serde(rename = "OKX DEX Router")]
    OkxDexRouter,
}
impl GetUltraV1OrderRoutersResponseName {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::Metis => "Metis",
            Self::JupiterZ => "JupiterZ",
            Self::Dflow => "DFlow",
            Self::OkxDexRouter => "OKX DEX Router",
        }
    }
}
impl ::std::fmt::Display for GetUltraV1OrderRoutersResponseName {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        f.write_str(self.as_str())
    }
}
impl AsRef<str> for GetUltraV1OrderRoutersResponseName {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct GetUltraV1OrderResponse {
    /**- This field will be present if `taker` is defined and `transaction` is an empty string
    - It is unique for each error scenarios
    */
    #[serde(rename = "errorCode", skip_serializing_if = "Option::is_none")]
    pub error_code: Option<f64>,
    /**- This field will be present if `taker` is defined and `transaction` is an empty string
    - This field can still return despite having a valid order/quote
    - This is meant for display purposes only and it is discouraged to match these error messages as they could be parameterized
    */
    #[serde(rename = "errorMessage", skip_serializing_if = "Option::is_none")]
    pub error_message: Option<GetUltraV1OrderResponseErrorMessage>,
    #[serde(rename = "expireAt", skip_serializing_if = "Option::is_none")]
    pub expire_at: Option<String>,
    /**- The fee includes either Ultra default fee or your integrator fee, depending on if referral and/or payer params are passed in
    - If `referralAccount`, `referralFee` (and `payer` if passed in) are passed in, the fee will be the integrator fee only
    - If no additional referral params are passed in, the fee will be the Ultra default fee only and can include additional fees for gasless support mechanism
    */
    #[serde(rename = "feeBps")]
    pub fee_bps: f64,
    #[serde(rename = "feeMint", skip_serializing_if = "Option::is_none")]
    pub fee_mint: Option<String>,
    pub gasless: bool,
    #[serde(rename = "inAmount")]
    pub in_amount: String,
    #[serde(rename = "inUsdValue", skip_serializing_if = "Option::is_none")]
    pub in_usd_value: Option<f64>,
    #[serde(rename = "inputMint")]
    pub input_mint: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub maker: Option<String>,
    pub mode: String,
    #[serde(rename = "otherAmountThreshold")]
    pub other_amount_threshold: String,
    #[serde(rename = "outAmount")]
    pub out_amount: String,
    #[serde(rename = "outUsdValue", skip_serializing_if = "Option::is_none")]
    pub out_usd_value: Option<f64>,
    #[serde(rename = "outputMint")]
    pub output_mint: String,
    /**- This field shows the platform fee only, does not include fee for gas
    - Platform fee can either be the Ultra default fee or your integrator fee
    */
    #[serde(rename = "platformFee")]
    pub platform_fee: GetUltraV1OrderResponsePlatformFee,
    #[serde(rename = "priceImpact", skip_serializing_if = "Option::is_none")]
    pub price_impact: Option<f64>,
    /**- Please use `priceImpact` field instead, this is still available only for backwards compatibility
     */
    #[serde(rename = "priceImpactPct")]
    pub price_impact_pct: String,
    /**- The number of lamports the `taker`, `maker` (JupiterZ's MM) or `payer` has to pay for higher priority landing, if a valid transaction is returned
    - Includes priority fees and tips for services such as Jito, etc, if any
    */
    #[serde(rename = "prioritizationFeeLamports")]
    pub prioritization_fee_lamports: f64,
    /**- The public key of the account that will cover the prioritization fee, it can be either `taker`, `maker` (JupiterZ's MM) or `payer` if passed in
     */
    #[serde(
        rename = "prioritizationFeePayer",
        skip_serializing_if = "Option::is_none"
    )]
    pub prioritization_fee_payer: Option<String>,
    #[serde(rename = "quoteId", skip_serializing_if = "Option::is_none")]
    pub quote_id: Option<String>,
    #[serde(rename = "referralAccount", skip_serializing_if = "Option::is_none")]
    pub referral_account: Option<String>,
    /**- The number of lamports the `taker` or `payer` has to pay for account rent, if a valid transaction is returned
    - Note that this value is just an estimate
    - For JupiterZ quotes, Jupiter's gas wallet pays the rent to create the taker's output token account if not yet initialised
    */
    #[serde(rename = "rentFeeLamports")]
    pub rent_fee_lamports: f64,
    /**- The public key of the account that will cover the rent fee, it can be either `taker`, `payer` if passed in, or Jupiter's gas wallet for JupiterZ quotes when the taker's output token account is not yet initialised
     */
    #[serde(rename = "rentFeePayer", skip_serializing_if = "Option::is_none")]
    pub rent_fee_payer: Option<String>,
    /**- Required to make a request to `/execute`
     */
    #[serde(rename = "requestId")]
    pub request_id: String,
    #[serde(rename = "routePlan")]
    pub route_plan: Vec<GetUltraV1OrderResponseRoutePlanItem>,
    pub router: GetUltraV1OrderResponseRouter,
    /**- The number of lamports the `taker`, `maker` (JupiterZ's MM) or `payer` has to pay for the base network fee, if a valid transaction is returned.
     */
    #[serde(rename = "signatureFeeLamports")]
    pub signature_fee_lamports: f64,
    /**- The public key of the account that will cover the signature fee, it can be either `taker`, `maker` (JupiterZ's MM) or `payer` if passed in
     */
    #[serde(rename = "signatureFeePayer", skip_serializing_if = "Option::is_none")]
    pub signature_fee_payer: Option<String>,
    #[serde(rename = "slippageBps")]
    pub slippage_bps: f64,
    #[serde(rename = "swapMode")]
    pub swap_mode: String,
    /**- Deprecated, in favour of router
     */
    #[serde(rename = "swapType")]
    pub swap_type: String,
    #[serde(rename = "swapUsdValue", skip_serializing_if = "Option::is_none")]
    pub swap_usd_value: Option<f64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub taker: Option<String>,
    #[serde(rename = "totalTime")]
    pub total_time: f64,
    /**- Unsigned base-64 encoded transaction to be signed and used in `/execute`
    - If `taker` is null, this field will be null.
    - If the `transaction` field is empty, it is returned with `errorCode` and `errorMessage` such as Insufficient Funds
    */
    #[serde(skip_serializing_if = "Option::is_none")]
    pub transaction: Option<String>,
}
#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize, Default)]
pub enum GetUltraV1OrderResponseRouter {
    #[default]
    #[serde(rename = "metis")]
    Metis,
    #[serde(rename = "jupiterz")]
    Jupiterz,
    #[serde(rename = "dflow")]
    Dflow,
    #[serde(rename = "okx")]
    Okx,
}
impl GetUltraV1OrderResponseRouter {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::Metis => "metis",
            Self::Jupiterz => "jupiterz",
            Self::Dflow => "dflow",
            Self::Okx => "okx",
        }
    }
}
impl ::std::fmt::Display for GetUltraV1OrderResponseRouter {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        f.write_str(self.as_str())
    }
}
impl AsRef<str> for GetUltraV1OrderResponseRouter {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct GetUltraV1OrderResponseRoutePlanItem {
    pub bps: f64,
    pub percent: f64,
    #[serde(rename = "swapInfo")]
    pub swap_info: GetUltraV1OrderResponseSwapInfo,
    #[serde(rename = "usdValue", skip_serializing_if = "Option::is_none")]
    pub usd_value: Option<f64>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct GetUltraV1OrderResponseSwapInfo {
    #[serde(rename = "ammKey")]
    pub amm_key: String,
    #[serde(rename = "inAmount")]
    pub in_amount: String,
    #[serde(rename = "inputMint")]
    pub input_mint: String,
    pub label: String,
    #[serde(rename = "outAmount")]
    pub out_amount: String,
    #[serde(rename = "outputMint")]
    pub output_mint: String,
}
/**- This field shows the platform fee only, does not include fee for gas
- Platform fee can either be the Ultra default fee or your integrator fee
*/
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct GetUltraV1OrderResponsePlatformFee {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub amount: Option<String>,
    #[serde(rename = "feeBps")]
    pub fee_bps: f64,
}
/**- This field will be present if `taker` is defined and `transaction` is an empty string
- This field can still return despite having a valid order/quote
- This is meant for display purposes only and it is discouraged to match these error messages as they could be parameterized
*/
#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize, Default)]
pub enum GetUltraV1OrderResponseErrorMessage {
    #[default]
    #[serde(rename = "Insufficient funds")]
    InsufficientFunds,
    #[serde(rename = "Top up `${solAmount}` SOL for gas")]
    TopUpSolAmountSolForGas,
    #[serde(rename = "Minimum `${swapAmount}` for gasless")]
    MinimumSwapAmountForGasless,
}
impl GetUltraV1OrderResponseErrorMessage {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::InsufficientFunds => "Insufficient funds",
            Self::TopUpSolAmountSolForGas => "Top up `${solAmount}` SOL for gas",
            Self::MinimumSwapAmountForGasless => "Minimum `${swapAmount}` for gasless",
        }
    }
}
impl ::std::fmt::Display for GetUltraV1OrderResponseErrorMessage {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        f.write_str(self.as_str())
    }
}
impl AsRef<str> for GetUltraV1OrderResponseErrorMessage {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct GetUltraV1BalancesAddressResponse {
    /// Additional properties matching the spec's
    /// `additionalProperties` value schema.
    #[serde(flatten)]
    pub additional_properties:
        std::collections::BTreeMap<String, GetUltraV1BalancesAddressResponseObject>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct GetUltraV1BalancesAddressResponseObject {
    pub amount: String,
    #[serde(rename = "isFrozen")]
    pub is_frozen: bool,
    pub slot: f64,
    #[serde(rename = "uiAmount")]
    pub ui_amount: f64,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct GetTriggerV2OrdersHistoryResponse {
    pub orders: Vec<TriggerV2OrderHistoryItem>,
    pub pagination: GetTriggerV2OrdersHistoryResponsePagination,
}
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct GetTriggerV2OrdersHistoryResponsePagination {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub limit: Option<f64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub offset: Option<f64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub total: Option<f64>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct TriggerV2OrderHistoryItem {
    #[serde(rename = "createdAt", skip_serializing_if = "Option::is_none")]
    pub created_at: Option<f64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub events: Option<Vec<TriggerV2OrderHistoryItemEventsItem>>,
    #[serde(rename = "expiresAt", skip_serializing_if = "Option::is_none")]
    pub expires_at: Option<f64>,
    #[serde(rename = "fillPercent", skip_serializing_if = "Option::is_none")]
    pub fill_percent: Option<f64>,
    ///Highest observed trigger-mint price (sell-below trailing).
    #[serde(rename = "highWatermark", skip_serializing_if = "Option::is_none")]
    pub high_watermark: Option<f64>,
    pub id: String,
    #[serde(rename = "initialInputAmount", skip_serializing_if = "Option::is_none")]
    pub initial_input_amount: Option<String>,
    #[serde(rename = "inputMint")]
    pub input_mint: String,
    #[serde(rename = "inputUsed", skip_serializing_if = "Option::is_none")]
    pub input_used: Option<String>,
    ///Lowest observed trigger-mint price (buy-above trailing).
    #[serde(rename = "lowWatermark", skip_serializing_if = "Option::is_none")]
    pub low_watermark: Option<f64>,
    #[serde(rename = "orderState")]
    pub order_state: TriggerV2OrderHistoryItemOrderState,
    #[serde(rename = "orderType")]
    pub order_type: TriggerV2OrderHistoryItemOrderType,
    #[serde(rename = "outputAmount", skip_serializing_if = "Option::is_none")]
    pub output_amount: Option<String>,
    #[serde(rename = "outputMint")]
    pub output_mint: String,
    #[serde(rename = "privyWalletPubkey", skip_serializing_if = "Option::is_none")]
    pub privy_wallet_pubkey: Option<String>,
    #[serde(rename = "rawState", skip_serializing_if = "Option::is_none")]
    pub raw_state: Option<String>,
    #[serde(
        rename = "remainingInputAmount",
        skip_serializing_if = "Option::is_none"
    )]
    pub remaining_input_amount: Option<String>,
    #[serde(rename = "slippageBps", skip_serializing_if = "Option::is_none")]
    pub slippage_bps: Option<f64>,
    ///Trailing stop loss trail distance in basis points. Null for non-trailing orders.
    #[serde(rename = "trailingBps", skip_serializing_if = "Option::is_none")]
    pub trailing_bps: Option<f64>,
    #[serde(rename = "triggerCondition", skip_serializing_if = "Option::is_none")]
    pub trigger_condition: Option<TriggerV2OrderHistoryItemTriggerCondition>,
    #[serde(rename = "triggerMint", skip_serializing_if = "Option::is_none")]
    pub trigger_mint: Option<String>,
    #[serde(rename = "triggerPriceUsd", skip_serializing_if = "Option::is_none")]
    pub trigger_price_usd: Option<f64>,
    #[serde(rename = "triggeredAt", skip_serializing_if = "Option::is_none")]
    pub triggered_at: Option<f64>,
    #[serde(rename = "updatedAt", skip_serializing_if = "Option::is_none")]
    pub updated_at: Option<f64>,
    #[serde(rename = "userPubkey")]
    pub user_pubkey: String,
}
#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize, Default)]
pub enum TriggerV2OrderHistoryItemTriggerCondition {
    #[default]
    #[serde(rename = "above")]
    Above,
    #[serde(rename = "below")]
    Below,
}
impl TriggerV2OrderHistoryItemTriggerCondition {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::Above => "above",
            Self::Below => "below",
        }
    }
}
impl ::std::fmt::Display for TriggerV2OrderHistoryItemTriggerCondition {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        f.write_str(self.as_str())
    }
}
impl AsRef<str> for TriggerV2OrderHistoryItemTriggerCondition {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}
#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize, Default)]
pub enum TriggerV2OrderHistoryItemOrderType {
    #[default]
    #[serde(rename = "single")]
    Single,
    #[serde(rename = "oco")]
    Oco,
    #[serde(rename = "otoco")]
    Otoco,
}
impl TriggerV2OrderHistoryItemOrderType {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::Single => "single",
            Self::Oco => "oco",
            Self::Otoco => "otoco",
        }
    }
}
impl ::std::fmt::Display for TriggerV2OrderHistoryItemOrderType {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        f.write_str(self.as_str())
    }
}
impl AsRef<str> for TriggerV2OrderHistoryItemOrderType {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}
#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize, Default)]
pub enum TriggerV2OrderHistoryItemOrderState {
    #[default]
    #[serde(rename = "pending")]
    Pending,
    #[serde(rename = "open")]
    Open,
    #[serde(rename = "executing")]
    Executing,
    #[serde(rename = "filled")]
    Filled,
    #[serde(rename = "pending_withdraw")]
    PendingWithdraw,
    #[serde(rename = "cancelled")]
    Cancelled,
    #[serde(rename = "expired")]
    Expired,
    #[serde(rename = "failed")]
    Failed,
}
impl TriggerV2OrderHistoryItemOrderState {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::Pending => "pending",
            Self::Open => "open",
            Self::Executing => "executing",
            Self::Filled => "filled",
            Self::PendingWithdraw => "pending_withdraw",
            Self::Cancelled => "cancelled",
            Self::Expired => "expired",
            Self::Failed => "failed",
        }
    }
}
impl ::std::fmt::Display for TriggerV2OrderHistoryItemOrderState {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        f.write_str(self.as_str())
    }
}
impl AsRef<str> for TriggerV2OrderHistoryItemOrderState {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct TriggerV2OrderHistoryItemEventsItem {
    ///Token amount in smallest unit (present on deposit/withdrawal events)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub amount: Option<String>,
    ///Token mint address (present on deposit/withdrawal events)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub mint: Option<String>,
    ///Order context identifier (present on fill events)
    #[serde(rename = "orderContext", skip_serializing_if = "Option::is_none")]
    pub order_context: Option<String>,
    ///Output token amount in smallest unit (present on fill events)
    #[serde(rename = "outputAmount", skip_serializing_if = "Option::is_none")]
    pub output_amount: Option<String>,
    ///Output token mint address (present on fill events)
    #[serde(rename = "outputMint", skip_serializing_if = "Option::is_none")]
    pub output_mint: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub state: Option<TriggerV2OrderHistoryItemState>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub timestamp: Option<f64>,
    #[serde(rename = "txSignature", skip_serializing_if = "Option::is_none")]
    pub tx_signature: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub r#type: Option<TriggerV2OrderHistoryItemType>,
}
#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize, Default)]
pub enum TriggerV2OrderHistoryItemType {
    #[default]
    #[serde(rename = "deposit")]
    Deposit,
    #[serde(rename = "fill")]
    Fill,
    #[serde(rename = "withdrawal")]
    Withdrawal,
    #[serde(rename = "cancelled")]
    Cancelled,
    #[serde(rename = "expired")]
    Expired,
}
impl TriggerV2OrderHistoryItemType {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::Deposit => "deposit",
            Self::Fill => "fill",
            Self::Withdrawal => "withdrawal",
            Self::Cancelled => "cancelled",
            Self::Expired => "expired",
        }
    }
}
impl ::std::fmt::Display for TriggerV2OrderHistoryItemType {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        f.write_str(self.as_str())
    }
}
impl AsRef<str> for TriggerV2OrderHistoryItemType {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}
#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize, Default)]
pub enum TriggerV2OrderHistoryItemState {
    #[default]
    #[serde(rename = "success")]
    Success,
    #[serde(rename = "failed")]
    Failed,
    #[serde(rename = "pending")]
    Pending,
}
impl TriggerV2OrderHistoryItemState {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::Success => "success",
            Self::Failed => "failed",
            Self::Pending => "pending",
        }
    }
}
impl ::std::fmt::Display for TriggerV2OrderHistoryItemState {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        f.write_str(self.as_str())
    }
}
impl AsRef<str> for TriggerV2OrderHistoryItemState {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct GetTriggerV2OrdersHistoryDcaResponse {
    pub orders: Vec<TriggerV2DcaHistoryItem>,
    pub pagination: GetTriggerV2OrdersHistoryDcaResponsePagination,
}
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct GetTriggerV2OrdersHistoryDcaResponsePagination {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub limit: Option<f64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub offset: Option<f64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub total: Option<f64>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct TriggerV2DcaHistoryItem {
    ///Amount swapped each round (the last round may include dust)
    #[serde(rename = "amountPerRound", skip_serializing_if = "Option::is_none")]
    pub amount_per_round: Option<String>,
    ///ISO-8601 time the first round is scheduled
    #[serde(rename = "beginFillAt", skip_serializing_if = "Option::is_none")]
    pub begin_fill_at: Option<String>,
    #[serde(rename = "createdAt", skip_serializing_if = "Option::is_none")]
    pub created_at: Option<String>,
    #[serde(rename = "displayState")]
    pub display_state: TriggerV2DcaHistoryItemDisplayState,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub events: Option<Vec<TriggerV2DcaHistoryItemEventsItem>>,
    ///Progress from 0 to 1
    #[serde(rename = "fillPercent", skip_serializing_if = "Option::is_none")]
    pub fill_percent: Option<f64>,
    ///DCA order UUID
    pub id: String,
    ///Total deposit amount in smallest units
    #[serde(rename = "inputAmountInitial", skip_serializing_if = "Option::is_none")]
    pub input_amount_initial: Option<String>,
    ///Amount still held in the vault
    #[serde(
        rename = "inputAmountRemaining",
        skip_serializing_if = "Option::is_none"
    )]
    pub input_amount_remaining: Option<String>,
    ///Total input consumed by successful rounds
    #[serde(rename = "inputAmountUsed", skip_serializing_if = "Option::is_none")]
    pub input_amount_used: Option<String>,
    #[serde(rename = "inputMint")]
    pub input_mint: String,
    #[serde(rename = "intervalSeconds", skip_serializing_if = "Option::is_none")]
    pub interval_seconds: Option<f64>,
    ///Whether Earn While You Wait is on for this order (idle funds earn Jupiter Lend yield between rounds).
    #[serde(rename = "jlEnabled", skip_serializing_if = "Option::is_none")]
    pub jl_enabled: Option<bool>,
    ///Yield earned so far in USD for an Earn While You Wait order, from the ~15 min price cache. null when not JL-enabled or a required price is uncached.
    #[serde(rename = "jlYieldUsd", skip_serializing_if = "Option::is_none")]
    pub jl_yield_usd: Option<f64>,
    #[serde(rename = "lastFillAt", skip_serializing_if = "Option::is_none")]
    pub last_fill_at: Option<String>,
    #[serde(rename = "maxPriceUsd", skip_serializing_if = "Option::is_none")]
    pub max_price_usd: Option<f64>,
    #[serde(rename = "minPriceUsd", skip_serializing_if = "Option::is_none")]
    pub min_price_usd: Option<f64>,
    ///ISO-8601 time of the next scheduled round
    #[serde(rename = "nextFillAt", skip_serializing_if = "Option::is_none")]
    pub next_fill_at: Option<String>,
    #[serde(rename = "numberOfRounds", skip_serializing_if = "Option::is_none")]
    pub number_of_rounds: Option<f64>,
    #[serde(rename = "orderType")]
    pub order_type: TriggerV2DcaHistoryItemOrderType,
    ///Total output received across all successful rounds
    #[serde(rename = "outputAmountTotal", skip_serializing_if = "Option::is_none")]
    pub output_amount_total: Option<String>,
    #[serde(rename = "outputMint")]
    pub output_mint: String,
    #[serde(rename = "requestId", skip_serializing_if = "Option::is_none")]
    pub request_id: Option<String>,
    ///Retry window per round in seconds, clamp(intervalSeconds/2, 30, 7200)
    #[serde(rename = "retryWindowSeconds", skip_serializing_if = "Option::is_none")]
    pub retry_window_seconds: Option<f64>,
    #[serde(rename = "roundsFilled", skip_serializing_if = "Option::is_none")]
    pub rounds_filled: Option<f64>,
    pub state: TriggerV2DcaHistoryItemStateDepositing,
    #[serde(rename = "triggerMint", skip_serializing_if = "Option::is_none")]
    pub trigger_mint: Option<String>,
    #[serde(rename = "updatedAt", skip_serializing_if = "Option::is_none")]
    pub updated_at: Option<String>,
    #[serde(rename = "userPubkey")]
    pub user_pubkey: String,
    #[serde(rename = "vaultPubkey")]
    pub vault_pubkey: String,
}
#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize, Default)]
pub enum TriggerV2DcaHistoryItemStateDepositing {
    #[default]
    #[serde(rename = "depositing")]
    Depositing,
    #[serde(rename = "deposit_failed")]
    DepositFailed,
    #[serde(rename = "active")]
    Active,
    #[serde(rename = "executing")]
    Executing,
    #[serde(rename = "withdrawing")]
    Withdrawing,
    #[serde(rename = "completed")]
    Completed,
    #[serde(rename = "cancelled")]
    Cancelled,
}
impl TriggerV2DcaHistoryItemStateDepositing {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::Depositing => "depositing",
            Self::DepositFailed => "deposit_failed",
            Self::Active => "active",
            Self::Executing => "executing",
            Self::Withdrawing => "withdrawing",
            Self::Completed => "completed",
            Self::Cancelled => "cancelled",
        }
    }
}
impl ::std::fmt::Display for TriggerV2DcaHistoryItemStateDepositing {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        f.write_str(self.as_str())
    }
}
impl AsRef<str> for TriggerV2DcaHistoryItemStateDepositing {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}
#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize, Default)]
pub enum TriggerV2DcaHistoryItemOrderType {
    #[default]
    #[serde(rename = "time_based")]
    TimeBased,
    #[serde(rename = "price_conditional")]
    PriceConditional,
}
impl TriggerV2DcaHistoryItemOrderType {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::TimeBased => "time_based",
            Self::PriceConditional => "price_conditional",
        }
    }
}
impl ::std::fmt::Display for TriggerV2DcaHistoryItemOrderType {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        f.write_str(self.as_str())
    }
}
impl AsRef<str> for TriggerV2DcaHistoryItemOrderType {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct TriggerV2DcaHistoryItemEventsItem {
    #[serde(rename = "attemptCount", skip_serializing_if = "Option::is_none")]
    pub attempt_count: Option<f64>,
    #[serde(rename = "inputAmount", skip_serializing_if = "Option::is_none")]
    pub input_amount: Option<String>,
    #[serde(rename = "outputAmount", skip_serializing_if = "Option::is_none")]
    pub output_amount: Option<String>,
    #[serde(rename = "roundNumber", skip_serializing_if = "Option::is_none")]
    pub round_number: Option<f64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub state: Option<TriggerV2DcaHistoryItemState>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub timestamp: Option<String>,
    #[serde(rename = "txSignature", skip_serializing_if = "Option::is_none")]
    pub tx_signature: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub r#type: Option<TriggerV2DcaHistoryItemType>,
}
#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize, Default)]
pub enum TriggerV2DcaHistoryItemType {
    #[default]
    #[serde(rename = "deposit")]
    Deposit,
    #[serde(rename = "fill")]
    Fill,
    #[serde(rename = "withdrawal")]
    Withdrawal,
    #[serde(rename = "cancelled")]
    Cancelled,
}
impl TriggerV2DcaHistoryItemType {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::Deposit => "deposit",
            Self::Fill => "fill",
            Self::Withdrawal => "withdrawal",
            Self::Cancelled => "cancelled",
        }
    }
}
impl ::std::fmt::Display for TriggerV2DcaHistoryItemType {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        f.write_str(self.as_str())
    }
}
impl AsRef<str> for TriggerV2DcaHistoryItemType {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}
#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize, Default)]
pub enum TriggerV2DcaHistoryItemState {
    #[default]
    #[serde(rename = "success")]
    Success,
    #[serde(rename = "failed")]
    Failed,
    #[serde(rename = "rescheduled")]
    Rescheduled,
    #[serde(rename = "pending")]
    Pending,
}
impl TriggerV2DcaHistoryItemState {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::Success => "success",
            Self::Failed => "failed",
            Self::Rescheduled => "rescheduled",
            Self::Pending => "pending",
        }
    }
}
impl ::std::fmt::Display for TriggerV2DcaHistoryItemState {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        f.write_str(self.as_str())
    }
}
impl AsRef<str> for TriggerV2DcaHistoryItemState {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}
#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize, Default)]
pub enum TriggerV2DcaHistoryItemDisplayState {
    #[default]
    #[serde(rename = "pending")]
    Pending,
    #[serde(rename = "active")]
    Active,
    #[serde(rename = "executing")]
    Executing,
    #[serde(rename = "pending_withdraw")]
    PendingWithdraw,
    #[serde(rename = "completed")]
    Completed,
    #[serde(rename = "cancelled")]
    Cancelled,
    #[serde(rename = "failed")]
    Failed,
}
impl TriggerV2DcaHistoryItemDisplayState {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::Pending => "pending",
            Self::Active => "active",
            Self::Executing => "executing",
            Self::PendingWithdraw => "pending_withdraw",
            Self::Completed => "completed",
            Self::Cancelled => "cancelled",
            Self::Failed => "failed",
        }
    }
}
impl ::std::fmt::Display for TriggerV2DcaHistoryItemDisplayState {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        f.write_str(self.as_str())
    }
}
impl AsRef<str> for TriggerV2DcaHistoryItemDisplayState {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct GetTriggerV1GetTriggerOrdersResponse {
    ///The status of the requested orders
    #[serde(rename = "orderStatus")]
    pub order_status: GetTriggerV1GetTriggerOrdersResponseOrderStatus,
    pub orders: Vec<GetTriggerV1GetTriggerOrdersResponseOrdersItem>,
    pub page: f64,
    ///Total number of pages
    #[serde(rename = "totalPages")]
    pub total_pages: f64,
    ///The requested user's wallet public key
    pub user: String,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct GetTriggerV1GetTriggerOrdersResponseOrdersItem {
    #[serde(rename = "closeTx")]
    pub close_tx: String,
    #[serde(rename = "createdAt")]
    pub created_at: String,
    #[serde(rename = "expiredAt", skip_serializing_if = "Option::is_none")]
    pub expired_at: Option<String>,
    #[serde(rename = "inputMint")]
    pub input_mint: String,
    #[serde(rename = "makingAmount")]
    pub making_amount: String,
    #[serde(rename = "openTx")]
    pub open_tx: String,
    #[serde(rename = "orderKey")]
    pub order_key: String,
    #[serde(rename = "outputMint")]
    pub output_mint: String,
    #[serde(rename = "programVersion")]
    pub program_version: String,
    #[serde(rename = "rawMakingAmount")]
    pub raw_making_amount: String,
    #[serde(rename = "rawRemainingMakingAmount")]
    pub raw_remaining_making_amount: String,
    #[serde(rename = "rawRemainingTakingAmount")]
    pub raw_remaining_taking_amount: String,
    #[serde(rename = "rawTakingAmount")]
    pub raw_taking_amount: String,
    #[serde(rename = "remainingMakingAmount")]
    pub remaining_making_amount: String,
    #[serde(rename = "remainingTakingAmount")]
    pub remaining_taking_amount: String,
    #[serde(rename = "slippageBps")]
    pub slippage_bps: String,
    /**An open order with trades indicates that it has been
    partially filled
    */
    pub status: String,
    #[serde(rename = "takingAmount")]
    pub taking_amount: String,
    pub trades: Vec<GetTriggerV1GetTriggerOrdersResponseTradesItem>,
    #[serde(rename = "updatedAt")]
    pub updated_at: String,
    #[serde(rename = "userPubkey")]
    pub user_pubkey: String,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct GetTriggerV1GetTriggerOrdersResponseTradesItem {
    pub action: String,
    #[serde(rename = "confirmedAt")]
    pub confirmed_at: String,
    #[serde(rename = "feeAmount")]
    pub fee_amount: String,
    #[serde(rename = "feeMint")]
    pub fee_mint: String,
    #[serde(rename = "inputAmount")]
    pub input_amount: String,
    #[serde(rename = "inputMint")]
    pub input_mint: String,
    pub keeper: String,
    #[serde(rename = "orderKey")]
    pub order_key: String,
    #[serde(rename = "outputAmount")]
    pub output_amount: String,
    #[serde(rename = "outputMint")]
    pub output_mint: String,
    #[serde(rename = "productMeta", skip_serializing_if = "Option::is_none")]
    pub product_meta: Option<serde_json::Value>,
    #[serde(rename = "rawFeeAmount")]
    pub raw_fee_amount: String,
    #[serde(rename = "rawInputAmount")]
    pub raw_input_amount: String,
    #[serde(rename = "rawOutputAmount")]
    pub raw_output_amount: String,
    #[serde(rename = "txId")]
    pub tx_id: String,
}
///The status of the requested orders
#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize, Default)]
pub enum GetTriggerV1GetTriggerOrdersResponseOrderStatus {
    #[default]
    #[serde(rename = "active")]
    Active,
    #[serde(rename = "history")]
    History,
}
impl GetTriggerV1GetTriggerOrdersResponseOrderStatus {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::Active => "active",
            Self::History => "history",
        }
    }
}
impl ::std::fmt::Display for GetTriggerV1GetTriggerOrdersResponseOrderStatus {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        f.write_str(self.as_str())
    }
}
impl AsRef<str> for GetTriggerV1GetTriggerOrdersResponseOrderStatus {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}
pub type GetTokensV2TagResponse = Vec<TokensV2MintInformation>;
pub type GetTokensV2SearchResponse = Vec<TokensV2MintInformation>;
pub type GetTokensV2RecentResponse = Vec<TokensV2MintInformation>;
pub type GetTokensV2CategoryIntervalResponse = Vec<TokensV2MintInformation>;
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct TokensV2MintInformation {
    ///APY data, only present for assets listed on Jupiter Lend's Earn
    #[serde(skip_serializing_if = "Option::is_none")]
    pub apy: Option<TokensV2MintInformationApy>,
    /**Audit information. All sub-fields are conditional and vary per token.
     */
    #[serde(skip_serializing_if = "Option::is_none")]
    pub audit: Option<TokensV2MintInformationAudit>,
    #[serde(rename = "circSupply", skip_serializing_if = "Option::is_none")]
    pub circ_supply: Option<f64>,
    ///Token creation timestamp
    #[serde(rename = "createdAt", skip_serializing_if = "Option::is_none")]
    pub created_at: Option<chrono::DateTime<chrono::Utc>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub decimals: Option<f64>,
    ///The token's developer wallet address
    #[serde(skip_serializing_if = "Option::is_none")]
    pub dev: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub discord: Option<String>,
    ///Fully diluted valuation in USD
    #[serde(skip_serializing_if = "Option::is_none")]
    pub fdv: Option<f64>,
    #[serde(rename = "firstPool", skip_serializing_if = "Option::is_none")]
    pub first_pool: Option<TokensV2MintInformationFirstPool>,
    ///Freeze authority address (present when freeze authority is not disabled)
    #[serde(rename = "freezeAuthority", skip_serializing_if = "Option::is_none")]
    pub freeze_authority: Option<String>,
    #[serde(rename = "graduatedAt", skip_serializing_if = "Option::is_none")]
    pub graduated_at: Option<String>,
    #[serde(rename = "graduatedPool", skip_serializing_if = "Option::is_none")]
    pub graduated_pool: Option<String>,
    #[serde(rename = "holderCount", skip_serializing_if = "Option::is_none")]
    pub holder_count: Option<f64>,
    ///URL to the token's logo image
    #[serde(skip_serializing_if = "Option::is_none")]
    pub icon: Option<String>,
    ///The token's mint address
    #[serde(skip_serializing_if = "Option::is_none")]
    pub id: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub instagram: Option<String>,
    #[serde(rename = "isVerified", skip_serializing_if = "Option::is_none")]
    pub is_verified: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub launchpad: Option<String>,
    ///Total liquidity in USD
    #[serde(skip_serializing_if = "Option::is_none")]
    pub liquidity: Option<f64>,
    ///Market cap in USD
    #[serde(skip_serializing_if = "Option::is_none")]
    pub mcap: Option<f64>,
    ///Mint authority address (present when mint authority is not disabled)
    #[serde(rename = "mintAuthority", skip_serializing_if = "Option::is_none")]
    pub mint_authority: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    ///Organic trading activity score (0-100)
    #[serde(rename = "organicScore", skip_serializing_if = "Option::is_none")]
    pub organic_score: Option<f64>,
    #[serde(rename = "organicScoreLabel", skip_serializing_if = "Option::is_none")]
    pub organic_score_label: Option<TokensV2MintInformationOrganicScoreLabel>,
    #[serde(rename = "otherUrl", skip_serializing_if = "Option::is_none")]
    pub other_url: Option<String>,
    #[serde(rename = "partnerConfig", skip_serializing_if = "Option::is_none")]
    pub partner_config: Option<String>,
    ///Solana block number for the price data point
    #[serde(rename = "priceBlockId", skip_serializing_if = "Option::is_none")]
    pub price_block_id: Option<f64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub stats1h: Option<TokensV2SwapStats>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub stats24h: Option<TokensV2SwapStats>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub stats5m: Option<TokensV2SwapStats>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub stats6h: Option<TokensV2SwapStats>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub symbol: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tags: Option<Vec<String>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub telegram: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tiktok: Option<String>,
    ///The token program address (SPL Token or Token-2022)
    #[serde(rename = "tokenProgram", skip_serializing_if = "Option::is_none")]
    pub token_program: Option<String>,
    #[serde(rename = "totalSupply", skip_serializing_if = "Option::is_none")]
    pub total_supply: Option<f64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub twitter: Option<String>,
    ///Last data update timestamp
    #[serde(rename = "updatedAt", skip_serializing_if = "Option::is_none")]
    pub updated_at: Option<chrono::DateTime<chrono::Utc>>,
    #[serde(rename = "usdPrice", skip_serializing_if = "Option::is_none")]
    pub usd_price: Option<f64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub website: Option<String>,
}
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct TokensV2SwapStats {
    #[serde(rename = "buyOrganicVolume", skip_serializing_if = "Option::is_none")]
    pub buy_organic_volume: Option<f64>,
    #[serde(rename = "buyVolume", skip_serializing_if = "Option::is_none")]
    pub buy_volume: Option<f64>,
    #[serde(rename = "holderChange", skip_serializing_if = "Option::is_none")]
    pub holder_change: Option<f64>,
    #[serde(rename = "liquidityChange", skip_serializing_if = "Option::is_none")]
    pub liquidity_change: Option<f64>,
    #[serde(rename = "numBuys", skip_serializing_if = "Option::is_none")]
    pub num_buys: Option<f64>,
    #[serde(rename = "numNetBuyers", skip_serializing_if = "Option::is_none")]
    pub num_net_buyers: Option<f64>,
    #[serde(rename = "numOrganicBuyers", skip_serializing_if = "Option::is_none")]
    pub num_organic_buyers: Option<f64>,
    #[serde(rename = "numSells", skip_serializing_if = "Option::is_none")]
    pub num_sells: Option<f64>,
    #[serde(rename = "numTraders", skip_serializing_if = "Option::is_none")]
    pub num_traders: Option<f64>,
    #[serde(rename = "priceChange", skip_serializing_if = "Option::is_none")]
    pub price_change: Option<f64>,
    #[serde(rename = "sellOrganicVolume", skip_serializing_if = "Option::is_none")]
    pub sell_organic_volume: Option<f64>,
    #[serde(rename = "sellVolume", skip_serializing_if = "Option::is_none")]
    pub sell_volume: Option<f64>,
    #[serde(rename = "volumeChange", skip_serializing_if = "Option::is_none")]
    pub volume_change: Option<f64>,
}
#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize, Default)]
pub enum TokensV2MintInformationOrganicScoreLabel {
    #[default]
    #[serde(rename = "high")]
    High,
    #[serde(rename = "medium")]
    Medium,
    #[serde(rename = "low")]
    Low,
}
impl TokensV2MintInformationOrganicScoreLabel {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::High => "high",
            Self::Medium => "medium",
            Self::Low => "low",
        }
    }
}
impl ::std::fmt::Display for TokensV2MintInformationOrganicScoreLabel {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        f.write_str(self.as_str())
    }
}
impl AsRef<str> for TokensV2MintInformationOrganicScoreLabel {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct TokensV2MintInformationFirstPool {
    ///Pool creation timestamp
    #[serde(rename = "createdAt", skip_serializing_if = "Option::is_none")]
    pub created_at: Option<String>,
    ///Pool address
    #[serde(skip_serializing_if = "Option::is_none")]
    pub id: Option<String>,
}
/**Audit information. All sub-fields are conditional and vary per token.
*/
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct TokensV2MintInformationAudit {
    /**Percentage of supply held by the developer, on a 0-100 scale
    (e.g. 2.5 means 2.5%, not the fraction 0.025).
    */
    #[serde(
        rename = "devBalancePercentage",
        skip_serializing_if = "Option::is_none"
    )]
    pub dev_balance_percentage: Option<f64>,
    ///Number of developer mint events
    #[serde(rename = "devMints", skip_serializing_if = "Option::is_none")]
    pub dev_mints: Option<f64>,
    #[serde(
        rename = "freezeAuthorityDisabled",
        skip_serializing_if = "Option::is_none"
    )]
    pub freeze_authority_disabled: Option<bool>,
    /**Flagged as suspicious. This field is only present when the token
    has been flagged — check for the field's presence, not its value.
    Not all risky tokens will have this flag.
    */
    #[serde(rename = "isSus", skip_serializing_if = "Option::is_none")]
    pub is_sus: Option<bool>,
    #[serde(
        rename = "mintAuthorityDisabled",
        skip_serializing_if = "Option::is_none"
    )]
    pub mint_authority_disabled: Option<bool>,
    /**Percentage of supply held by the top holders, on a 0-100 scale
    (e.g. 25.07 means 25.07%, not the fraction 0.2507).
    */
    #[serde(
        rename = "topHoldersPercentage",
        skip_serializing_if = "Option::is_none"
    )]
    pub top_holders_percentage: Option<f64>,
}
///APY data, only present for assets listed on Jupiter Lend's Earn
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct TokensV2MintInformationApy {
    ///Annual percentage yield from Jupiter Earn
    #[serde(rename = "jupEarn", skip_serializing_if = "Option::is_none")]
    pub jup_earn: Option<f64>,
}
pub type GetTokensV1NewResponse = Vec<TokensV1MintWithCreationTimeAndMarkets>;
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct TokensV1MintWithCreationTimeAndMarkets {
    pub created_at: chrono::DateTime<chrono::Utc>,
    pub decimals: i32,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub freeze_authority: Option<String>,
    pub known_markets: Vec<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub logo_uri: Option<String>,
    pub metadata_updated_at: chrono::DateTime<chrono::Utc>,
    pub mint: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub mint_authority: Option<String>,
    pub name: String,
    pub symbol: String,
}
pub type GetTokensV1AllResponse = Vec<TokensV1Mint>;
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct TokensV1Mint {
    pub address: String,
    pub created_at: chrono::DateTime<chrono::Utc>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub daily_volume: Option<f64>,
    pub decimals: i32,
    pub extensions: serde_json::Value,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub freeze_authority: Option<String>,
    #[serde(rename = "logoURI", skip_serializing_if = "Option::is_none")]
    pub logo_uri: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub mint_authority: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub minted_at: Option<chrono::DateTime<chrono::Utc>>,
    pub name: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub permanent_delegate: Option<String>,
    pub symbol: String,
    pub tags: Vec<String>,
}
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct GetStudioV1DbcPoolAddressesMintResponse {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub data: Option<GetStudioV1DbcPoolAddressesMintResponseData>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub success: Option<bool>,
}
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct GetStudioV1DbcPoolAddressesMintResponseData {
    #[serde(rename = "configKey", skip_serializing_if = "Option::is_none")]
    pub config_key: Option<String>,
    #[serde(rename = "dammv2PoolAddress", skip_serializing_if = "Option::is_none")]
    pub dammv2_pool_address: Option<String>,
    #[serde(rename = "dbcPoolAddress", skip_serializing_if = "Option::is_none")]
    pub dbc_pool_address: Option<String>,
}
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct GetPriceV3Response {
    /// Additional properties matching the spec's
    /// `additionalProperties` value schema.
    #[serde(flatten)]
    pub additional_properties: std::collections::BTreeMap<String, GetPriceV3ResponseObject>,
}
///Token addresses as keys
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct GetPriceV3ResponseObject {
    ///Solana block ID when price was computed
    #[serde(rename = "blockId", skip_serializing_if = "Option::is_none")]
    pub block_id: Option<i64>,
    ///When the token was minted or created (fixed date for legacy tokens like SOL/USDC that predate the API)
    #[serde(rename = "createdAt")]
    pub created_at: chrono::DateTime<chrono::Utc>,
    ///Token decimal places
    pub decimals: i64,
    ///Total liquidity in USD across all pools
    pub liquidity: f64,
    ///24-hour price change as a percentage
    #[serde(rename = "priceChange24h", skip_serializing_if = "Option::is_none")]
    pub price_change24h: Option<f64>,
    ///Current USD price
    #[serde(rename = "usdPrice")]
    pub usd_price: f64,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct GetPredictionV1VaultInfoResponse {
    pub data: GetPredictionV1VaultInfoResponseData,
    pub pubkey: String,
    #[serde(rename = "vaultBalance")]
    pub vault_balance: String,
}
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct GetPredictionV1VaultInfoResponseData {
    /// Additional properties matching the spec's
    /// `additionalProperties` value schema.
    #[serde(flatten)]
    pub additional_properties: std::collections::BTreeMap<String, String>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct GetPredictionV1TradesResponse {
    pub data: Vec<GetPredictionV1TradesResponseDataItem>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct GetPredictionV1TradesResponseDataItem {
    pub action: GetPredictionV1TradesResponseAction,
    #[serde(rename = "amountUsd")]
    pub amount_usd: String,
    #[serde(rename = "eventId")]
    pub event_id: String,
    #[serde(rename = "eventImageUrl")]
    pub event_image_url: String,
    #[serde(rename = "eventTitle")]
    pub event_title: String,
    ///Trade identifier (e.g. "order-1906029")
    pub id: String,
    #[serde(rename = "isTeamMarket", skip_serializing_if = "Option::is_none")]
    pub is_team_market: Option<bool>,
    #[serde(rename = "marketId")]
    pub market_id: String,
    #[serde(rename = "marketOptions", skip_serializing_if = "Option::is_none")]
    pub market_options: Option<Vec<GetPredictionV1TradesResponseMarketOptionsItem>>,
    #[serde(rename = "marketTitle")]
    pub market_title: String,
    pub message: String,
    #[serde(rename = "ownerPubkey")]
    pub owner_pubkey: String,
    #[serde(rename = "priceUsd")]
    pub price_usd: String,
    pub side: GetPredictionV1TradesResponseSide,
    pub timestamp: f64,
}
#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize, Default)]
pub enum GetPredictionV1TradesResponseSide {
    #[default]
    #[serde(rename = "yes")]
    Yes,
    #[serde(rename = "no")]
    No,
}
impl GetPredictionV1TradesResponseSide {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::Yes => "yes",
            Self::No => "no",
        }
    }
}
impl ::std::fmt::Display for GetPredictionV1TradesResponseSide {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        f.write_str(self.as_str())
    }
}
impl AsRef<str> for GetPredictionV1TradesResponseSide {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct GetPredictionV1TradesResponseMarketOptionsItem {
    #[serde(rename = "buyYes", skip_serializing_if = "Option::is_none")]
    pub buy_yes: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub label: Option<String>,
}
#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize, Default)]
pub enum GetPredictionV1TradesResponseAction {
    #[default]
    #[serde(rename = "buy")]
    Buy,
    #[serde(rename = "sell")]
    Sell,
}
impl GetPredictionV1TradesResponseAction {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::Buy => "buy",
            Self::Sell => "sell",
        }
    }
}
impl ::std::fmt::Display for GetPredictionV1TradesResponseAction {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        f.write_str(self.as_str())
    }
}
impl AsRef<str> for GetPredictionV1TradesResponseAction {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct GetPredictionV1ProfilesOwnerPubkeyPnlHistoryResponse {
    pub history: Vec<GetPredictionV1ProfilesOwnerPubkeyPnlHistoryResponseHistoryItem>,
    #[serde(rename = "ownerPubkey")]
    pub owner_pubkey: String,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct GetPredictionV1ProfilesOwnerPubkeyPnlHistoryResponseHistoryItem {
    #[serde(rename = "realizedPnlUsd")]
    pub realized_pnl_usd: String,
    pub timestamp: i64,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct GetPredictionV1PositionsResponse {
    pub data: Vec<PredictionPosition>,
    pub pagination: GetPredictionV1PositionsResponsePagination,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct GetPredictionV1PositionsResponsePagination {
    ///Constraint: minimum=0
    pub end: i64,
    #[serde(rename = "hasNext")]
    pub has_next: bool,
    ///Constraint: minimum=0
    pub start: i64,
    ///Constraint: minimum=0
    pub total: i64,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PredictionPosition {
    ///Average entry price per contract in micro USD (u64 as string)
    #[serde(rename = "avgPriceUsd")]
    pub avg_price_usd: String,
    ///Constraint: minimum=0
    pub bump: i64,
    ///True when the position qualifies for payout claim
    pub claimable: bool,
    ///Unix timestamp (seconds) when the position becomes claimable; null when unavailable
    #[serde(rename = "claimableAt", skip_serializing_if = "Option::is_none")]
    pub claimable_at: Option<i64>,
    ///Whether payout has been claimed
    pub claimed: bool,
    ///Amount claimed in micro USD (u64 as string)
    #[serde(rename = "claimedUsd")]
    pub claimed_usd: String,
    ///Legacy whole-contract quantity held. Use contractsMicro or contractsDecimal for the exact fractional quantity.
    pub contracts: String,
    ///Contracts held as a decimal string
    #[serde(rename = "contractsDecimal", skip_serializing_if = "Option::is_none")]
    pub contracts_decimal: Option<String>,
    ///Contracts held in micro-contract units (u64 as string, 1000000 = 1 contract)
    #[serde(rename = "contractsMicro", skip_serializing_if = "Option::is_none")]
    pub contracts_micro: Option<String>,
    ///External event identifier if available
    #[serde(rename = "eventId")]
    pub event_id: String,
    #[serde(rename = "eventMetadata")]
    pub event_metadata: PredictionEventMetadata,
    ///Total fees paid in micro USD (u64 as string)
    #[serde(rename = "feesPaidUsd")]
    pub fees_paid_usd: String,
    ///True if this is a YES position
    #[serde(rename = "isYes")]
    pub is_yes: bool,
    ///Current mark price per contract in micro USD (u64 as string); null once market is closed
    #[serde(rename = "markPriceUsd", skip_serializing_if = "Option::is_none")]
    pub mark_price_usd: Option<String>,
    ///Deterministic market PDA derived from marketId
    pub market: String,
    ///External market identifier (ticker)
    #[serde(rename = "marketId")]
    pub market_id: String,
    ///Hashed market identifier used for on-chain PDAs
    #[serde(rename = "marketIdHash")]
    pub market_id_hash: String,
    #[serde(rename = "marketMetadata")]
    pub market_metadata: serde_json::Value,
    ///Maximum slippage recorded for the position, in basis points
    ///Constraint: minimum=0
    #[serde(rename = "maxSlippageBps", skip_serializing_if = "Option::is_none")]
    pub max_slippage_bps: Option<i64>,
    ///Number of open orders
    ///Constraint: minimum=0
    #[serde(rename = "openOrders")]
    pub open_orders: i64,
    ///Unix timestamp when the position was opened
    #[serde(rename = "openedAt")]
    pub opened_at: i64,
    ///Position owner public key
    pub owner: String,
    ///Position owner public key (alias of owner, prefer ownerPubkey going forward)
    #[serde(rename = "ownerPubkey")]
    pub owner_pubkey: String,
    ///Notional payout if position wins (contracts * $1)
    #[serde(rename = "payoutUsd")]
    pub payout_usd: String,
    ///Unrealized PnL in micro USD (i128 as string); null once market is closed
    #[serde(rename = "pnlUsd", skip_serializing_if = "Option::is_none")]
    pub pnl_usd: Option<String>,
    ///Unrealized PnL after fees in micro USD (i128 as string); null once market is closed
    #[serde(rename = "pnlUsdAfterFees", skip_serializing_if = "Option::is_none")]
    pub pnl_usd_after_fees: Option<String>,
    ///Unrealized PnL after fees percentage relative to size; null once market is closed
    #[serde(
        rename = "pnlUsdAfterFeesPercent",
        skip_serializing_if = "Option::is_none"
    )]
    pub pnl_usd_after_fees_percent: Option<f64>,
    ///Unrealized PnL percentage relative to size; null once market is closed
    #[serde(rename = "pnlUsdPercent", skip_serializing_if = "Option::is_none")]
    pub pnl_usd_percent: Option<f64>,
    ///Position account public key
    pub pubkey: String,
    ///Realized PnL in micro USD (i64 as number)
    #[serde(rename = "realizedPnlUsd")]
    pub realized_pnl_usd: f64,
    ///Current best exit price for this side (micro USD string), or null when unavailable
    #[serde(rename = "sellPriceUsd", skip_serializing_if = "Option::is_none")]
    pub sell_price_usd: Option<String>,
    ///Unix timestamp (seconds) when the market settles; null when unavailable
    #[serde(rename = "settlementDate", skip_serializing_if = "Option::is_none")]
    pub settlement_date: Option<i64>,
    ///Alias of total cost basis in micro USD (u128 as string)
    #[serde(rename = "sizeUsd")]
    pub size_usd: String,
    ///Origin of the position (e.g. "program")
    #[serde(skip_serializing_if = "Option::is_none")]
    pub source: Option<String>,
    ///Total cost basis in micro USD (u128 as string)
    #[serde(rename = "totalCostUsd")]
    pub total_cost_usd: String,
    ///Unix timestamp of the last position update
    #[serde(rename = "updatedAt")]
    pub updated_at: i64,
    ///Mark-to-market value in micro USD (u128 as string); null once market is closed
    #[serde(rename = "valueUsd", skip_serializing_if = "Option::is_none")]
    pub value_usd: Option<String>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct GetPredictionV1OrdersStatusOrderPubkeyResponse {
    #[serde(rename = "externalOrderId")]
    pub external_order_id: String,
    pub history: Vec<GetPredictionV1OrdersStatusOrderPubkeyResponseHistoryItem>,
    #[serde(rename = "latestEventType")]
    pub latest_event_type: String,
    #[serde(rename = "latestSignature")]
    pub latest_signature: String,
    #[serde(rename = "orderId")]
    pub order_id: String,
    #[serde(rename = "orderPubkey")]
    pub order_pubkey: String,
    pub status: String,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct GetPredictionV1OrdersStatusOrderPubkeyResponseHistoryItem {
    #[serde(rename = "eventType")]
    pub event_type: String,
    #[serde(rename = "externalOrderId")]
    pub external_order_id: String,
    #[serde(rename = "orderId")]
    pub order_id: String,
    #[serde(rename = "rawStatus")]
    pub raw_status: String,
    pub signature: String,
    pub status: String,
    pub timestamp: i64,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct GetPredictionV1OrdersResponse {
    pub data: Vec<PredictionOrder>,
    pub pagination: GetPredictionV1OrdersResponsePagination,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct GetPredictionV1OrdersResponsePagination {
    ///Constraint: minimum=0
    pub end: i64,
    #[serde(rename = "hasNext")]
    pub has_next: bool,
    ///Constraint: minimum=0
    pub start: i64,
    ///Constraint: minimum=0
    pub total: i64,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PredictionOrder {
    ///Average fill price in micro USD (u64 as string)
    #[serde(rename = "avgFillPriceUsd")]
    pub avg_fill_price_usd: String,
    ///Constraint: minimum=0
    pub bump: i64,
    ///Number of contracts (u64 as string)
    pub contracts: String,
    ///Unix timestamp (seconds) when the order was created
    #[serde(rename = "createdAt")]
    pub created_at: i64,
    ///External event identifier
    #[serde(rename = "eventId")]
    pub event_id: String,
    #[serde(rename = "eventMetadata")]
    pub event_metadata: PredictionEventMetadata,
    ///Client-provided order identifier
    #[serde(rename = "externalOrderId")]
    pub external_order_id: String,
    ///Unix timestamp (seconds) when the order was filled (0 when pending)
    #[serde(rename = "filledAt")]
    pub filled_at: i64,
    ///Number of filled contracts (u64 as string)
    #[serde(rename = "filledContracts")]
    pub filled_contracts: String,
    ///True when order is a buy order
    #[serde(rename = "isBuy")]
    pub is_buy: bool,
    ///True when order is for the YES side
    #[serde(rename = "isYes")]
    pub is_yes: bool,
    ///Associated market public key
    pub market: String,
    ///External market identifier used to derive the PDA
    #[serde(rename = "marketId")]
    pub market_id: String,
    ///Hashed market identifier used for on-chain PDAs
    #[serde(rename = "marketIdHash")]
    pub market_id_hash: String,
    #[serde(rename = "marketMetadata")]
    pub market_metadata: serde_json::Value,
    ///Buyer-specified max fill price (micro USD)
    #[serde(rename = "maxBuyPriceUsd", skip_serializing_if = "Option::is_none")]
    pub max_buy_price_usd: Option<String>,
    ///Maximum fill price in micro USD (u64 as string)
    #[serde(rename = "maxFillPriceUsd")]
    pub max_fill_price_usd: String,
    ///Seller-specified min fill price (micro USD)
    #[serde(rename = "minSellPriceUsd", skip_serializing_if = "Option::is_none")]
    pub min_sell_price_usd: Option<String>,
    ///External order identifier from the venue
    #[serde(rename = "orderId")]
    pub order_id: String,
    ///Order owner public key
    pub owner: String,
    ///Order owner public key (alias of owner, use ownerPubkey when available)
    #[serde(rename = "ownerPubkey")]
    pub owner_pubkey: String,
    ///Associated position public key
    pub position: String,
    ///Order account public key
    pub pubkey: String,
    ///Whether the order has been settled on-chain
    pub settled: bool,
    ///Order notional in micro USD (u128 as string)
    #[serde(rename = "sizeUsd")]
    pub size_usd: String,
    ///Current order status
    pub status: PredictionOrderStatus,
    ///Unix timestamp (seconds) when the order last changed on-chain
    #[serde(rename = "updatedAt")]
    pub updated_at: i64,
}
///Current order status
#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize, Default)]
pub enum PredictionOrderStatus {
    #[default]
    #[serde(rename = "pending")]
    Pending,
    #[serde(rename = "filled")]
    Filled,
    #[serde(rename = "failed")]
    Failed,
}
impl PredictionOrderStatus {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::Pending => "pending",
            Self::Filled => "filled",
            Self::Failed => "failed",
        }
    }
}
impl ::std::fmt::Display for PredictionOrderStatus {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        f.write_str(self.as_str())
    }
}
impl AsRef<str> for PredictionOrderStatus {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct GetPredictionV1LeaderboardsResponse {
    pub data: Vec<GetPredictionV1LeaderboardsResponseDataItem>,
    pub summary: GetPredictionV1LeaderboardsResponseSummary,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct GetPredictionV1LeaderboardsResponseSummary {
    pub all_time: GetPredictionV1LeaderboardsResponseAllTime,
    pub monthly: GetPredictionV1LeaderboardsResponseMonthly,
    pub weekly: GetPredictionV1LeaderboardsResponseWeekly,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct GetPredictionV1LeaderboardsResponseWeekly {
    #[serde(rename = "predictionsCount")]
    pub predictions_count: f64,
    #[serde(rename = "totalVolumeUsd")]
    pub total_volume_usd: String,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct GetPredictionV1LeaderboardsResponseMonthly {
    #[serde(rename = "predictionsCount")]
    pub predictions_count: f64,
    #[serde(rename = "totalVolumeUsd")]
    pub total_volume_usd: String,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct GetPredictionV1LeaderboardsResponseAllTime {
    #[serde(rename = "predictionsCount")]
    pub predictions_count: f64,
    #[serde(rename = "totalVolumeUsd")]
    pub total_volume_usd: String,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct GetPredictionV1LeaderboardsResponseDataItem {
    #[serde(rename = "correctPredictions")]
    pub correct_predictions: f64,
    #[serde(rename = "ownerPubkey")]
    pub owner_pubkey: String,
    pub period: String,
    #[serde(rename = "periodEnd", skip_serializing_if = "Option::is_none")]
    pub period_end: Option<String>,
    #[serde(rename = "periodStart", skip_serializing_if = "Option::is_none")]
    pub period_start: Option<String>,
    #[serde(rename = "predictionsCount")]
    pub predictions_count: f64,
    #[serde(rename = "realizedPnlUsd")]
    pub realized_pnl_usd: String,
    #[serde(rename = "totalVolumeUsd")]
    pub total_volume_usd: String,
    #[serde(rename = "winRatePct")]
    pub win_rate_pct: String,
    #[serde(rename = "wrongPredictions")]
    pub wrong_predictions: f64,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct GetPredictionV1HistoryResponse {
    pub data: Vec<PredictionHistoryEvent>,
    pub pagination: PredictionPagination,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PredictionHistoryEvent {
    ///Average fill price in micro USD (u64 as string)
    #[serde(rename = "avgFillPriceUsd")]
    pub avg_fill_price_usd: String,
    ///Number of contracts in the order. Legacy whole-contract value; see contractsMicro/contractsDecimal for the exact quantity.
    pub contracts: String,
    ///Contracts as a decimal string
    #[serde(rename = "contractsDecimal", skip_serializing_if = "Option::is_none")]
    pub contracts_decimal: Option<String>,
    ///Contracts in micro-contract units (u64 as string, 1000000 = 1 contract)
    #[serde(rename = "contractsMicro", skip_serializing_if = "Option::is_none")]
    pub contracts_micro: Option<String>,
    ///Number of contracts settled in this event (legacy whole-contract value)
    #[serde(rename = "contractsSettled")]
    pub contracts_settled: String,
    ///Settled contracts as a decimal string
    #[serde(
        rename = "contractsSettledDecimal",
        skip_serializing_if = "Option::is_none"
    )]
    pub contracts_settled_decimal: Option<String>,
    ///Settled contracts in micro-contract units
    #[serde(
        rename = "contractsSettledMicro",
        skip_serializing_if = "Option::is_none"
    )]
    pub contracts_settled_micro: Option<String>,
    ///Amount deposited for this order in micro USD (u64 as string)
    #[serde(rename = "depositAmountUsd")]
    pub deposit_amount_usd: String,
    ///External event identifier
    #[serde(rename = "eventId")]
    pub event_id: String,
    #[serde(rename = "eventMetadata")]
    pub event_metadata: PredictionEventMetadata,
    ///Type of history event. Position wins surface as payout_claimed (there is no position_won).
    #[serde(rename = "eventType")]
    pub event_type: PredictionHistoryEventEventType,
    ///Client-provided order identifier
    #[serde(rename = "externalOrderId")]
    pub external_order_id: String,
    ///Fee charged for this event in micro USD (u64 as string)
    #[serde(rename = "feeUsd", skip_serializing_if = "Option::is_none")]
    pub fee_usd: Option<String>,
    ///Number of contracts filled (legacy whole-contract value)
    #[serde(rename = "filledContracts")]
    pub filled_contracts: String,
    ///Filled contracts as a decimal string
    #[serde(
        rename = "filledContractsDecimal",
        skip_serializing_if = "Option::is_none"
    )]
    pub filled_contracts_decimal: Option<String>,
    ///Filled contracts in micro-contract units
    #[serde(
        rename = "filledContractsMicro",
        skip_serializing_if = "Option::is_none"
    )]
    pub filled_contracts_micro: Option<String>,
    ///Gross proceeds before fees in micro USD (u64 as string)
    #[serde(rename = "grossProceedsUsd")]
    pub gross_proceeds_usd: String,
    ///Unique history event identifier
    pub id: i64,
    ///True when the event relates to a buy order
    #[serde(rename = "isBuy")]
    pub is_buy: bool,
    ///True when the event relates to the YES side
    #[serde(rename = "isYes")]
    pub is_yes: bool,
    ///Keeper that processed the transaction
    #[serde(rename = "keeperPubkey")]
    pub keeper_pubkey: String,
    ///External market identifier
    #[serde(rename = "marketId")]
    pub market_id: String,
    ///Metadata for the associated market
    #[serde(rename = "marketMetadata")]
    pub market_metadata: serde_json::Value,
    ///Buyer-specified max fill price in micro USD (u64 as string)
    #[serde(rename = "maxBuyPriceUsd", skip_serializing_if = "Option::is_none")]
    pub max_buy_price_usd: Option<String>,
    ///Maximum fill price in micro USD (u64 as string)
    #[serde(rename = "maxFillPriceUsd")]
    pub max_fill_price_usd: String,
    ///Seller-specified min fill price in micro USD (u64 as string)
    #[serde(rename = "minSellPriceUsd", skip_serializing_if = "Option::is_none")]
    pub min_sell_price_usd: Option<String>,
    ///Net proceeds after fees in micro USD (u64 as string)
    #[serde(rename = "netProceedsUsd")]
    pub net_proceeds_usd: String,
    ///External order identifier from the venue
    #[serde(rename = "orderId")]
    pub order_id: String,
    ///Associated order account public key
    #[serde(rename = "orderPubkey")]
    pub order_pubkey: String,
    ///Position or order owner public key
    #[serde(rename = "ownerPubkey")]
    pub owner_pubkey: String,
    ///Payout amount in micro USD (u64 as string), populated for payout_claimed events
    #[serde(rename = "payoutAmountUsd")]
    pub payout_amount_usd: String,
    ///Associated position account public key
    #[serde(rename = "positionPubkey")]
    pub position_pubkey: String,
    ///Realized PnL from this event in micro USD (i64 as string)
    #[serde(rename = "realizedPnl", skip_serializing_if = "Option::is_none")]
    pub realized_pnl: Option<String>,
    ///Realized PnL before fees in micro USD (i64 as string)
    #[serde(
        rename = "realizedPnlBeforeFees",
        skip_serializing_if = "Option::is_none"
    )]
    pub realized_pnl_before_fees: Option<String>,
    ///Solana transaction signature
    pub signature: String,
    ///Solana slot number (u64 as string)
    pub slot: String,
    ///Unix timestamp (seconds) when the event occurred
    pub timestamp: i64,
    ///Total cost of the order in micro USD (u64 as string)
    #[serde(rename = "totalCostUsd")]
    pub total_cost_usd: String,
    ///Token amount transferred in this event (native token units as string)
    #[serde(
        rename = "transferAmountToken",
        skip_serializing_if = "Option::is_none"
    )]
    pub transfer_amount_token: Option<String>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PredictionMarketMetadata {
    #[serde(rename = "closeTime", skip_serializing_if = "Option::is_none")]
    pub close_time: Option<f64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    #[serde(rename = "eventId", skip_serializing_if = "Option::is_none")]
    pub event_id: Option<String>,
    #[serde(rename = "isTeamMarket", skip_serializing_if = "Option::is_none")]
    pub is_team_market: Option<bool>,
    #[serde(rename = "marketId")]
    pub market_id: String,
    #[serde(rename = "marketOptions", skip_serializing_if = "Option::is_none")]
    pub market_options: Option<Vec<PredictionMarketMetadataMarketOptionsItem>>,
    #[serde(rename = "openTime", skip_serializing_if = "Option::is_none")]
    pub open_time: Option<f64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub provider: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub result: Option<String>,
    #[serde(rename = "rulesPrimary", skip_serializing_if = "Option::is_none")]
    pub rules_primary: Option<String>,
    #[serde(rename = "rulesSecondary", skip_serializing_if = "Option::is_none")]
    pub rules_secondary: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub status: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub subtitle: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub title: Option<String>,
}
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct PredictionMarketMetadataMarketOptionsItem {
    #[serde(rename = "buyYes", skip_serializing_if = "Option::is_none")]
    pub buy_yes: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub label: Option<String>,
}
///Type of history event. Position wins surface as payout_claimed (there is no position_won).
#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize, Default)]
pub enum PredictionHistoryEventEventType {
    #[default]
    #[serde(rename = "order_created")]
    OrderCreated,
    #[serde(rename = "order_filled")]
    OrderFilled,
    #[serde(rename = "order_failed")]
    OrderFailed,
    #[serde(rename = "order_closed")]
    OrderClosed,
    #[serde(rename = "payout_claimed")]
    PayoutClaimed,
    #[serde(rename = "position_updated")]
    PositionUpdated,
    #[serde(rename = "position_lost")]
    PositionLost,
}
impl PredictionHistoryEventEventType {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::OrderCreated => "order_created",
            Self::OrderFilled => "order_filled",
            Self::OrderFailed => "order_failed",
            Self::OrderClosed => "order_closed",
            Self::PayoutClaimed => "payout_claimed",
            Self::PositionUpdated => "position_updated",
            Self::PositionLost => "position_lost",
        }
    }
}
impl ::std::fmt::Display for PredictionHistoryEventEventType {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        f.write_str(self.as_str())
    }
}
impl AsRef<str> for PredictionHistoryEventEventType {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct GetPredictionV1ForecastResponse {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub forecast_history: Option<Vec<GetPredictionV1ForecastResponseForecastHistoryItem>>,
}
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct GetPredictionV1ForecastResponseForecastHistoryItem {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub end_period_ts: Option<f64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub event_ticker: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub formatted_forecast: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub market_ticker: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub numerical_forecast: Option<f64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub period_interval: Option<f64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub raw_numerical_forecast: Option<f64>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct GetPredictionV1EventsSuggestedPubkeyResponse {
    pub data: Vec<PredictionEvent>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct GetPredictionV1EventsSearchResponse {
    pub data: Vec<PredictionEvent>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pagination: Option<PredictionPagination>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct GetPredictionV1EventsScoresResponse {
    pub data: Vec<PredictionGameScore>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PredictionGameScore {
    #[serde(rename = "awayTeam", skip_serializing_if = "Option::is_none")]
    pub away_team: Option<String>,
    ///Elapsed time within the game (e.g. "90")
    #[serde(skip_serializing_if = "Option::is_none")]
    pub elapsed: Option<String>,
    ///True once the game has finished
    pub ended: bool,
    ///Application-level event identifier
    #[serde(rename = "eventId")]
    pub event_id: String,
    ///ISO 8601 timestamp when the game finished, if ended
    #[serde(rename = "finishedTimestamp", skip_serializing_if = "Option::is_none")]
    pub finished_timestamp: Option<String>,
    #[serde(rename = "gameId")]
    pub game_id: String,
    #[serde(rename = "homeTeam", skip_serializing_if = "Option::is_none")]
    pub home_team: Option<String>,
    #[serde(rename = "leagueAbbreviation", skip_serializing_if = "Option::is_none")]
    pub league_abbreviation: Option<String>,
    ///True while the game is in progress
    pub live: bool,
    ///Current period (e.g. "2H")
    #[serde(skip_serializing_if = "Option::is_none")]
    pub period: Option<String>,
    ///Raw score string from the provider (e.g. "2-0")
    #[serde(skip_serializing_if = "Option::is_none")]
    pub score: Option<String>,
    ///Provider status string (e.g. "InProgress")
    #[serde(skip_serializing_if = "Option::is_none")]
    pub status: Option<String>,
    ///ISO 8601 timestamp of the last score update
    #[serde(rename = "updatedAt")]
    pub updated_at: String,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct GetPredictionV1EventsResponse {
    pub data: Vec<PredictionEvent>,
    pub pagination: PredictionPagination,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PredictionEvent {
    ///Unix timestamp (seconds) when the event begins
    #[serde(rename = "beginAt", skip_serializing_if = "Option::is_none")]
    pub begin_at: Option<String>,
    ///The category for the event, allowed values: all, crypto, sports, politics, esports, culture, economics, tech
    pub category: String,
    ///Close condition for the event
    #[serde(rename = "closeCondition")]
    pub close_condition: String,
    ///Application-level identifier
    #[serde(rename = "eventId")]
    pub event_id: String,
    ///Whether the event is active (listed on events)
    #[serde(rename = "isActive")]
    pub is_active: bool,
    ///Whether the event is currently live
    #[serde(rename = "isLive")]
    pub is_live: bool,
    ///Live score data for sports events; null when no score is available
    #[serde(rename = "liveScore", skip_serializing_if = "Option::is_none")]
    pub live_score: Option<serde_json::Value>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub markets: Option<Vec<PredictionMarket>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub metadata: Option<PredictionEventMetadata>,
    ///Document to full rules for the event
    #[serde(rename = "rulesPdf")]
    pub rules_pdf: String,
    ///The subcategory for the event
    pub subcategory: String,
    ///Tags associated with the event
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tags: Option<Vec<String>>,
    ///Rolling 24-hour volume in micro USD
    #[serde(skip_serializing_if = "Option::is_none")]
    pub volume24hr: Option<String>,
    ///Total volume for the event in micro USD
    #[serde(rename = "volumeUsd")]
    pub volume_usd: String,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PredictionEventMetadata {
    ///ISO 8601 formatted close time
    #[serde(rename = "closeTime", skip_serializing_if = "Option::is_none")]
    pub close_time: Option<String>,
    #[serde(rename = "eventId")]
    pub event_id: String,
    #[serde(rename = "imageUrl", skip_serializing_if = "Option::is_none")]
    pub image_url: Option<url::Url>,
    #[serde(rename = "isLive", skip_serializing_if = "Option::is_none")]
    pub is_live: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub series: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub slug: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub subtitle: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub title: Option<String>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct GetPredictionV1EventsEventIdMarketsResponse {
    pub data: Vec<PredictionMarket>,
    pub pagination: PredictionPagination,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PredictionPagination {
    ///Constraint: minimum=0
    pub end: i64,
    #[serde(rename = "hasNext")]
    pub has_next: bool,
    ///Constraint: minimum=0
    pub start: i64,
    ///Constraint: minimum=0
    pub total: i64,
}
///Market fields are returned flat (there is no nested `metadata` object).
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PredictionMarket {
    ///Underlying CLOB token IDs (provider-specific)
    #[serde(rename = "clobTokenIds", skip_serializing_if = "Option::is_none")]
    pub clob_token_ids: Option<Vec<String>>,
    ///Unix timestamp (seconds) when the market closes
    #[serde(rename = "closeTime")]
    pub close_time: f64,
    ///Parent event identifier
    #[serde(rename = "eventId", skip_serializing_if = "Option::is_none")]
    pub event_id: Option<String>,
    ///Market image URL
    #[serde(rename = "imageUrl", skip_serializing_if = "Option::is_none")]
    pub image_url: Option<url::Url>,
    ///True for team or sports markets
    #[serde(rename = "isTeamMarket", skip_serializing_if = "Option::is_none")]
    pub is_team_market: Option<bool>,
    ///Jupiter Forecast trading lifecycle: `open`, `resolving` after the close time, or `settled` after issuer resolution. Only `open` is tradable.
    #[serde(rename = "lifecycleStatus", skip_serializing_if = "Option::is_none")]
    pub lifecycle_status: Option<PredictionMarketLifecycleStatus>,
    ///Market identifier
    #[serde(rename = "marketId")]
    pub market_id: String,
    ///Selectable options for team or multi-outcome markets
    #[serde(rename = "marketOptions", skip_serializing_if = "Option::is_none")]
    pub market_options: Option<Vec<PredictionMarketMarketOptionsItem>>,
    ///On-chain market account (Jupiter Forecast / bisonfi).
    #[serde(rename = "marketPda", skip_serializing_if = "Option::is_none")]
    pub market_pda: Option<String>,
    ///Public key of the market result account
    #[serde(rename = "marketResultPubkey", skip_serializing_if = "Option::is_none")]
    pub market_result_pubkey: Option<String>,
    ///Unix timestamp (seconds) when the market opens
    #[serde(rename = "openTime")]
    pub open_time: f64,
    ///Outcome token mint for this market side (Jupiter Forecast / bisonfi). Buying the market gives you this token; it can also be traded directly through the Swap API.
    #[serde(rename = "outcomeMint", skip_serializing_if = "Option::is_none")]
    pub outcome_mint: Option<String>,
    ///Outcome side for Jupiter Forecast markets (`up` or `down`).
    #[serde(rename = "outcomeSide", skip_serializing_if = "Option::is_none")]
    pub outcome_side: Option<String>,
    ///Token program that owns `outcomeMint`. Jupiter Forecast uses Token-2022 (`TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb`).
    #[serde(
        rename = "outcomeTokenProgram",
        skip_serializing_if = "Option::is_none"
    )]
    pub outcome_token_program: Option<String>,
    ///Outcome labels for the market
    #[serde(skip_serializing_if = "Option::is_none")]
    pub outcomes: Option<Vec<String>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub pricing: Option<PredictionMarketPricing>,
    ///Market data provider
    #[serde(skip_serializing_if = "Option::is_none")]
    pub provider: Option<PredictionMarketProvider>,
    ///When the market resolved. null while open; returned as an ISO 8601 string once resolved
    #[serde(rename = "resolveAt", skip_serializing_if = "Option::is_none")]
    pub resolve_at: Option<PredictionMarketResolveAt>,
    ///Market result. null until resolved, then "yes" or "no"
    #[serde(skip_serializing_if = "Option::is_none")]
    pub result: Option<PredictionMarketResult>,
    ///Primary resolution rules
    #[serde(rename = "rulesPrimary", skip_serializing_if = "Option::is_none")]
    pub rules_primary: Option<String>,
    ///Secondary resolution rules
    #[serde(rename = "rulesSecondary", skip_serializing_if = "Option::is_none")]
    pub rules_secondary: Option<String>,
    ///Sports line or handicap, when applicable
    #[serde(rename = "sportsLine", skip_serializing_if = "Option::is_none")]
    pub sports_line: Option<f64>,
    ///Sports market type, when applicable
    #[serde(rename = "sportsMarketType", skip_serializing_if = "Option::is_none")]
    pub sports_market_type: Option<String>,
    ///Current market status
    pub status: PredictionMarketStatus,
    ///Team metadata, present for team markets
    #[serde(skip_serializing_if = "Option::is_none")]
    pub team: Option<serde_json::Value>,
    ///Market title
    #[serde(skip_serializing_if = "Option::is_none")]
    pub title: Option<String>,
    ///Whether this Jupiter Forecast side can be traded right now. The Discover example filters on this field.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tradable: Option<bool>,
}
///Current market status
#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize, Default)]
pub enum PredictionMarketStatus {
    #[default]
    #[serde(rename = "open")]
    Open,
    #[serde(rename = "closed")]
    Closed,
    #[serde(rename = "cancelled")]
    Cancelled,
}
impl PredictionMarketStatus {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::Open => "open",
            Self::Closed => "closed",
            Self::Cancelled => "cancelled",
        }
    }
}
impl ::std::fmt::Display for PredictionMarketStatus {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        f.write_str(self.as_str())
    }
}
impl AsRef<str> for PredictionMarketStatus {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}
///Market result. null until resolved, then "yes" or "no"
#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize, Default)]
pub enum PredictionMarketResult {
    #[default]
    #[serde(rename = "yes")]
    Yes,
    #[serde(rename = "no")]
    No,
}
impl PredictionMarketResult {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::Yes => "yes",
            Self::No => "no",
        }
    }
}
impl ::std::fmt::Display for PredictionMarketResult {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        f.write_str(self.as_str())
    }
}
impl AsRef<str> for PredictionMarketResult {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}
///When the market resolved. null while open; returned as an ISO 8601 string once resolved
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
pub enum PredictionMarketResolveAt {
    String(String),
    Number(f64),
}
///Market data provider
#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize, Default)]
pub enum PredictionMarketProvider {
    #[default]
    #[serde(rename = "polymarket")]
    Polymarket,
    #[serde(rename = "gx")]
    Gx,
    #[serde(rename = "bisonfi")]
    Bisonfi,
}
impl PredictionMarketProvider {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::Polymarket => "polymarket",
            Self::Gx => "gx",
            Self::Bisonfi => "bisonfi",
        }
    }
}
impl ::std::fmt::Display for PredictionMarketProvider {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        f.write_str(self.as_str())
    }
}
impl AsRef<str> for PredictionMarketProvider {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct PredictionMarketPricing {
    #[serde(rename = "buyNoPriceUsd", skip_serializing_if = "Option::is_none")]
    pub buy_no_price_usd: Option<f64>,
    #[serde(rename = "buyYesPriceUsd", skip_serializing_if = "Option::is_none")]
    pub buy_yes_price_usd: Option<f64>,
    #[serde(rename = "sellNoPriceUsd", skip_serializing_if = "Option::is_none")]
    pub sell_no_price_usd: Option<f64>,
    #[serde(rename = "sellYesPriceUsd", skip_serializing_if = "Option::is_none")]
    pub sell_yes_price_usd: Option<f64>,
    ///Trading volume for this market
    #[serde(skip_serializing_if = "Option::is_none")]
    pub volume: Option<f64>,
}
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct PredictionMarketMarketOptionsItem {
    #[serde(rename = "buyYes", skip_serializing_if = "Option::is_none")]
    pub buy_yes: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub label: Option<String>,
}
///Jupiter Forecast trading lifecycle: `open`, `resolving` after the close time, or `settled` after issuer resolution. Only `open` is tradable.
#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize, Default)]
pub enum PredictionMarketLifecycleStatus {
    #[default]
    #[serde(rename = "open")]
    Open,
    #[serde(rename = "resolving")]
    Resolving,
    #[serde(rename = "settled")]
    Settled,
}
impl PredictionMarketLifecycleStatus {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::Open => "open",
            Self::Resolving => "resolving",
            Self::Settled => "settled",
        }
    }
}
impl ::std::fmt::Display for PredictionMarketLifecycleStatus {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        f.write_str(self.as_str())
    }
}
impl AsRef<str> for PredictionMarketLifecycleStatus {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct GetPortfolioV1StakedJupAddressResponse {
    #[serde(rename = "stakedAmount", skip_serializing_if = "Option::is_none")]
    pub staked_amount: Option<f64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub unstaking: Option<Vec<GetPortfolioV1StakedJupAddressResponseUnstakingItem>>,
}
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct GetPortfolioV1StakedJupAddressResponseUnstakingItem {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub amount: Option<f64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub until: Option<f64>,
}
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct GetPortfolioV1PositionsAddressResponse {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub date: Option<f64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub duration: Option<f64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub elements: Option<Vec<PortfolioPortfolioElement>>,
    #[serde(rename = "fetcherReports", skip_serializing_if = "Option::is_none")]
    pub fetcher_reports: Option<Vec<PortfolioFetcherReport>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub owner: Option<String>,
    #[serde(rename = "tokenInfo", skip_serializing_if = "Option::is_none")]
    pub token_info: Option<GetPortfolioV1PositionsAddressResponseTokenInfo>,
}
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct GetPortfolioV1PositionsAddressResponseTokenInfo {
    ///Tokens indexed by token address
    #[serde(skip_serializing_if = "Option::is_none")]
    pub solana: Option<GetPortfolioV1PositionsAddressResponseSolana>,
}
///Tokens indexed by token address
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct GetPortfolioV1PositionsAddressResponseSolana {
    /// Additional properties matching the spec's
    /// `additionalProperties` value schema.
    #[serde(flatten)]
    pub additional_properties: std::collections::BTreeMap<String, PortfolioTokenInfo>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PortfolioTokenInfo {
    ///Token address
    pub address: String,
    ///Number of decimals for the token
    pub decimals: f64,
    ///URI of the token logo
    #[serde(rename = "logoURI", skip_serializing_if = "Option::is_none")]
    pub logo_uri: Option<String>,
    ///Token name
    pub name: String,
    ///Token symbol
    pub symbol: String,
    ///Tags associated with the token
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tags: Option<Vec<String>>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(tag = "type")]
pub enum PortfolioPortfolioElement {
    #[serde(rename = "multiple")]
    PortfolioPortfolioElementMultiple(PortfolioPortfolioElementMultiple),
    #[serde(rename = "liquidity")]
    PortfolioPortfolioElementLiquidity(PortfolioPortfolioElementLiquidity),
    #[serde(rename = "leverage")]
    PortfolioPortfolioElementLeverage(PortfolioPortfolioElementLeverage),
    #[serde(rename = "borrowlend")]
    PortfolioPortfolioElementBorrowLend(PortfolioPortfolioElementBorrowLend),
    #[serde(rename = "trade")]
    PortfolioPortfolioElementTrade(PortfolioPortfolioElementTrade),
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PortfolioPortfolioElementTrade {
    pub data: PortfolioPortfolioElementTradeData,
    pub label: PortfolioPortfolioElementLabel,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(rename = "netApy", skip_serializing_if = "Option::is_none")]
    pub net_apy: Option<PortfolioNetApy>,
    #[serde(rename = "networkId")]
    pub network_id: PortfolioNetworkId,
    #[serde(rename = "platformId")]
    pub platform_id: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tags: Option<PortfolioTags>,
    pub value: f64,
}
#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize, Default)]
pub enum PortfolioPortfolioElementTradeType {
    #[default]
    #[serde(rename = "trade")]
    Trade,
}
impl PortfolioPortfolioElementTradeType {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::Trade => "trade",
        }
    }
}
impl ::std::fmt::Display for PortfolioPortfolioElementTradeType {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        f.write_str(self.as_str())
    }
}
impl AsRef<str> for PortfolioPortfolioElementTradeType {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PortfolioPortfolioElementTradeData {
    pub assets: PortfolioPortfolioElementTradeAssets,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub contract: Option<String>,
    ///Created at timestamp in ms
    #[serde(rename = "createdAt", skip_serializing_if = "Option::is_none")]
    pub created_at: Option<f64>,
    #[serde(
        rename = "expectedOutputAmount",
        skip_serializing_if = "Option::is_none"
    )]
    pub expected_output_amount: Option<f64>,
    ///Expire at timestamp in ms
    #[serde(rename = "expireAt", skip_serializing_if = "Option::is_none")]
    pub expire_at: Option<f64>,
    ///Filled percentage between 0 and 1
    #[serde(rename = "filledPercentage")]
    pub filled_percentage: f64,
    #[serde(rename = "initialInputAmount")]
    pub initial_input_amount: f64,
    #[serde(rename = "inputAddress")]
    pub input_address: String,
    #[serde(rename = "inputPrice")]
    pub input_price: f64,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub link: Option<String>,
    #[serde(rename = "outputAddress")]
    pub output_address: String,
    #[serde(rename = "outputPrice")]
    pub output_price: f64,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub recurring: Option<PortfolioPortfolioElementTradeRecurring>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub r#ref: Option<PortfolioRef>,
    #[serde(rename = "sourceRefs", skip_serializing_if = "Option::is_none")]
    pub source_refs: Option<Vec<PortfolioSourceRef>>,
    #[serde(rename = "withdrawnOutputAmount")]
    pub withdrawn_output_amount: f64,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PortfolioPortfolioElementTradeRecurring {
    ///The total number of orders
    pub cycles: f64,
    ///The interval between two orders in ms
    pub interval: f64,
    #[serde(rename = "priceRange", skip_serializing_if = "Option::is_none")]
    pub price_range: Option<PortfolioPortfolioElementTradePriceRange>,
}
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct PortfolioPortfolioElementTradePriceRange {
    ///Maximum usd price
    #[serde(skip_serializing_if = "Option::is_none")]
    pub max: Option<f64>,
    ///Minimum usd price
    #[serde(skip_serializing_if = "Option::is_none")]
    pub min: Option<f64>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PortfolioPortfolioElementTradeAssets {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub input: Option<PortfolioPortfolioAsset>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub output: Option<PortfolioPortfolioAsset>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PortfolioPortfolioElementMultiple {
    pub data: PortfolioPortfolioElementMultipleData,
    pub label: PortfolioPortfolioElementLabel,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(rename = "netApy", skip_serializing_if = "Option::is_none")]
    pub net_apy: Option<PortfolioNetApy>,
    #[serde(rename = "networkId")]
    pub network_id: PortfolioNetworkId,
    #[serde(rename = "platformId")]
    pub platform_id: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tags: Option<PortfolioTags>,
    pub value: f64,
}
#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize, Default)]
pub enum PortfolioPortfolioElementMultipleType {
    #[default]
    #[serde(rename = "multiple")]
    Multiple,
}
impl PortfolioPortfolioElementMultipleType {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::Multiple => "multiple",
        }
    }
}
impl ::std::fmt::Display for PortfolioPortfolioElementMultipleType {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        f.write_str(self.as_str())
    }
}
impl AsRef<str> for PortfolioPortfolioElementMultipleType {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PortfolioPortfolioElementMultipleData {
    pub assets: Vec<PortfolioPortfolioAsset>,
    #[serde(rename = "assetsYields", skip_serializing_if = "Option::is_none")]
    pub assets_yields: Option<Vec<Vec<PortfolioYield>>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub link: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub r#ref: Option<PortfolioRef>,
    #[serde(rename = "sourceRefs", skip_serializing_if = "Option::is_none")]
    pub source_refs: Option<Vec<PortfolioSourceRef>>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PortfolioPortfolioElementLiquidity {
    pub data: PortfolioPortfolioElementLiquidityData,
    pub label: PortfolioPortfolioElementLabel,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(rename = "netApy", skip_serializing_if = "Option::is_none")]
    pub net_apy: Option<PortfolioNetApy>,
    #[serde(rename = "networkId")]
    pub network_id: PortfolioNetworkId,
    #[serde(rename = "platformId")]
    pub platform_id: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tags: Option<PortfolioTags>,
    pub value: f64,
}
#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize, Default)]
pub enum PortfolioPortfolioElementLiquidityType {
    #[default]
    #[serde(rename = "liquidity")]
    Liquidity,
}
impl PortfolioPortfolioElementLiquidityType {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::Liquidity => "liquidity",
        }
    }
}
impl ::std::fmt::Display for PortfolioPortfolioElementLiquidityType {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        f.write_str(self.as_str())
    }
}
impl AsRef<str> for PortfolioPortfolioElementLiquidityType {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PortfolioPortfolioElementLiquidityData {
    pub liquidities: Vec<PortfolioPortfolioLiquidity>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PortfolioPortfolioLiquidity {
    pub assets: Vec<PortfolioPortfolioAsset>,
    #[serde(rename = "assetsValue")]
    pub assets_value: f64,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub contract: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub link: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub lp: Option<PortfolioLiquidityLp>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub r#ref: Option<PortfolioRef>,
    #[serde(rename = "rewardAssets")]
    pub reward_assets: Vec<PortfolioPortfolioAsset>,
    #[serde(rename = "rewardAssetsValue")]
    pub reward_assets_value: f64,
    #[serde(rename = "sourceRefs", skip_serializing_if = "Option::is_none")]
    pub source_refs: Option<Vec<PortfolioSourceRef>>,
    pub value: f64,
    pub yields: Vec<PortfolioYield>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PortfolioLiquidityLp {
    pub amount: f64,
    pub mint: String,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PortfolioPortfolioElementLeverage {
    pub data: PortfolioPortfolioElementLeverageData,
    pub label: PortfolioPortfolioElementLabel,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(rename = "netApy", skip_serializing_if = "Option::is_none")]
    pub net_apy: Option<PortfolioNetApy>,
    #[serde(rename = "networkId")]
    pub network_id: PortfolioNetworkId,
    #[serde(rename = "platformId")]
    pub platform_id: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tags: Option<PortfolioTags>,
    pub value: f64,
}
#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize, Default)]
pub enum PortfolioPortfolioElementLeverageType {
    #[default]
    #[serde(rename = "leverage")]
    Leverage,
}
impl PortfolioPortfolioElementLeverageType {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::Leverage => "leverage",
        }
    }
}
impl ::std::fmt::Display for PortfolioPortfolioElementLeverageType {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        f.write_str(self.as_str())
    }
}
impl AsRef<str> for PortfolioPortfolioElementLeverageType {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PortfolioPortfolioElementLeverageData {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub contract: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub cross: Option<PortfolioPortfolioElementLeverageCross>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub isolated: Option<PortfolioPortfolioElementLeverageIsolated>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub link: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub r#ref: Option<PortfolioRef>,
    #[serde(rename = "sourceRefs", skip_serializing_if = "Option::is_none")]
    pub source_refs: Option<Vec<PortfolioSourceRef>>,
    ///Total value (total equity)
    pub value: f64,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PortfolioPortfolioElementLeverageIsolated {
    pub positions: Vec<PortfolioIsoLevPosition>,
    pub value: f64,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PortfolioPortfolioElementLeverageCross {
    #[serde(rename = "collateralAssets", skip_serializing_if = "Option::is_none")]
    pub collateral_assets: Option<Vec<PortfolioPortfolioAsset>>,
    #[serde(rename = "collateralValue")]
    pub collateral_value: f64,
    ///Sum of positions sizeValue / cross value
    #[serde(skip_serializing_if = "Option::is_none")]
    pub leverage: Option<f64>,
    pub positions: Vec<PortfolioCrossLevPosition>,
    pub value: f64,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PortfolioIsoLevPosition {
    ///Address of the leveraged asset if it exists
    #[serde(skip_serializing_if = "Option::is_none")]
    pub address: Option<String>,
    #[serde(rename = "collateralValue")]
    pub collateral_value: f64,
    #[serde(rename = "entryPrice")]
    pub entry_price: f64,
    #[serde(rename = "imageUri", skip_serializing_if = "Option::is_none")]
    pub image_uri: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub leverage: Option<f64>,
    #[serde(rename = "liquidationPrice")]
    pub liquidation_price: f64,
    #[serde(rename = "markPrice")]
    pub mark_price: f64,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(rename = "pnlValue")]
    pub pnl_value: f64,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub r#ref: Option<String>,
    pub side: PortfolioIsoLevPositionSide,
    pub size: f64,
    #[serde(rename = "sizeValue")]
    pub size_value: f64,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sl: Option<f64>,
    #[serde(rename = "sourceRefs", skip_serializing_if = "Option::is_none")]
    pub source_refs: Option<Vec<PortfolioSourceRef>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tp: Option<f64>,
    pub value: f64,
}
#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize, Default)]
pub enum PortfolioIsoLevPositionSide {
    #[default]
    #[serde(rename = "long")]
    Long,
    #[serde(rename = "short")]
    Short,
}
impl PortfolioIsoLevPositionSide {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::Long => "long",
            Self::Short => "short",
        }
    }
}
impl ::std::fmt::Display for PortfolioIsoLevPositionSide {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        f.write_str(self.as_str())
    }
}
impl AsRef<str> for PortfolioIsoLevPositionSide {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PortfolioCrossLevPosition {
    ///Address of the leveraged asset if it exists
    #[serde(skip_serializing_if = "Option::is_none")]
    pub address: Option<String>,
    #[serde(rename = "entryPrice")]
    pub entry_price: f64,
    #[serde(rename = "imageUri", skip_serializing_if = "Option::is_none")]
    pub image_uri: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub leverage: Option<f64>,
    #[serde(rename = "liquidationPrice")]
    pub liquidation_price: f64,
    #[serde(rename = "markPrice")]
    pub mark_price: f64,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(rename = "pnlValue")]
    pub pnl_value: f64,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub r#ref: Option<String>,
    pub side: PortfolioCrossLevPositionSide,
    pub size: f64,
    #[serde(rename = "sizeValue")]
    pub size_value: f64,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub sl: Option<f64>,
    #[serde(rename = "sourceRefs", skip_serializing_if = "Option::is_none")]
    pub source_refs: Option<Vec<PortfolioSourceRef>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tp: Option<f64>,
    pub value: f64,
}
#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize, Default)]
pub enum PortfolioCrossLevPositionSide {
    #[default]
    #[serde(rename = "long")]
    Long,
    #[serde(rename = "short")]
    Short,
}
impl PortfolioCrossLevPositionSide {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::Long => "long",
            Self::Short => "short",
        }
    }
}
impl ::std::fmt::Display for PortfolioCrossLevPositionSide {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        f.write_str(self.as_str())
    }
}
impl AsRef<str> for PortfolioCrossLevPositionSide {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PortfolioPortfolioElementBorrowLend {
    pub data: PortfolioPortfolioElementBorrowLendData,
    pub label: PortfolioPortfolioElementLabel,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(rename = "netApy", skip_serializing_if = "Option::is_none")]
    pub net_apy: Option<PortfolioNetApy>,
    #[serde(rename = "networkId")]
    pub network_id: PortfolioNetworkId,
    #[serde(rename = "platformId")]
    pub platform_id: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tags: Option<PortfolioTags>,
    pub value: f64,
}
#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize, Default)]
pub enum PortfolioPortfolioElementLabel {
    #[default]
    #[serde(rename = "Wallet")]
    Wallet,
    #[serde(rename = "Staked")]
    Staked,
    #[serde(rename = "LiquidityPool")]
    LiquidityPool,
    #[serde(rename = "Farming")]
    Farming,
    #[serde(rename = "Vault")]
    Vault,
    #[serde(rename = "Lending")]
    Lending,
    #[serde(rename = "Vesting")]
    Vesting,
    #[serde(rename = "Deposit")]
    Deposit,
    #[serde(rename = "Rewards")]
    Rewards,
    #[serde(rename = "Airdrop")]
    Airdrop,
    #[serde(rename = "Margin")]
    Margin,
    #[serde(rename = "LimitOrder")]
    LimitOrder,
    #[serde(rename = "DCA")]
    Dca,
    #[serde(rename = "SmartDCA")]
    SmartDca,
    #[serde(rename = "Leverage")]
    Leverage,
}
impl PortfolioPortfolioElementLabel {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::Wallet => "Wallet",
            Self::Staked => "Staked",
            Self::LiquidityPool => "LiquidityPool",
            Self::Farming => "Farming",
            Self::Vault => "Vault",
            Self::Lending => "Lending",
            Self::Vesting => "Vesting",
            Self::Deposit => "Deposit",
            Self::Rewards => "Rewards",
            Self::Airdrop => "Airdrop",
            Self::Margin => "Margin",
            Self::LimitOrder => "LimitOrder",
            Self::Dca => "DCA",
            Self::SmartDca => "SmartDCA",
            Self::Leverage => "Leverage",
        }
    }
}
impl ::std::fmt::Display for PortfolioPortfolioElementLabel {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        f.write_str(self.as_str())
    }
}
impl AsRef<str> for PortfolioPortfolioElementLabel {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}
#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize, Default)]
pub enum PortfolioPortfolioElementBorrowLendType {
    #[default]
    #[serde(rename = "borrowlend")]
    Borrowlend,
}
impl PortfolioPortfolioElementBorrowLendType {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::Borrowlend => "borrowlend",
        }
    }
}
impl ::std::fmt::Display for PortfolioPortfolioElementBorrowLendType {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        f.write_str(self.as_str())
    }
}
impl AsRef<str> for PortfolioPortfolioElementBorrowLendType {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PortfolioPortfolioElementBorrowLendData {
    #[serde(rename = "borrowedAssets")]
    pub borrowed_assets: Vec<PortfolioPortfolioAsset>,
    #[serde(rename = "borrowedValue")]
    pub borrowed_value: f64,
    #[serde(rename = "borrowedYields")]
    pub borrowed_yields: Vec<Vec<PortfolioYield>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub contract: Option<String>,
    ///Date (in ms) when the loan will expire
    #[serde(rename = "expireOn", skip_serializing_if = "Option::is_none")]
    pub expire_on: Option<f64>,
    ///Health ratio (1 = full health, 0 or below = can be liquidated, null = unknown)
    #[serde(rename = "healthRatio", skip_serializing_if = "Option::is_none")]
    pub health_ratio: Option<f64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub link: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub r#ref: Option<PortfolioRef>,
    #[serde(rename = "rewardAssets")]
    pub reward_assets: Vec<PortfolioPortfolioAsset>,
    #[serde(rename = "rewardValue")]
    pub reward_value: f64,
    #[serde(rename = "sourceRefs", skip_serializing_if = "Option::is_none")]
    pub source_refs: Option<Vec<PortfolioSourceRef>>,
    #[serde(rename = "suppliedAssets")]
    pub supplied_assets: Vec<PortfolioPortfolioAsset>,
    #[serde(rename = "suppliedValue")]
    pub supplied_value: f64,
    #[serde(rename = "suppliedYields")]
    pub supplied_yields: Vec<Vec<PortfolioYield>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub unsettled: Option<PortfolioPortfolioElementBorrowLendUnsettled>,
    ///The value of the portfolio element in USD
    pub value: f64,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PortfolioPortfolioElementBorrowLendUnsettled {
    pub assets: Vec<PortfolioPortfolioAssetGeneric>,
    pub value: f64,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(tag = "type")]
pub enum PortfolioPortfolioAsset {
    #[serde(rename = "generic")]
    PortfolioPortfolioAssetGeneric(PortfolioPortfolioAssetGeneric),
    #[serde(rename = "token")]
    PortfolioPortfolioAssetToken(PortfolioPortfolioAssetToken),
    #[serde(rename = "collectible")]
    PortfolioPortfolioAssetCollectible(PortfolioPortfolioAssetCollectible),
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PortfolioPortfolioAssetToken {
    pub attributes: PortfolioPortfolioAssetAttributes,
    pub data: PortfolioPortfolioAssetTokenData,
    #[serde(rename = "imageUri", skip_serializing_if = "Option::is_none")]
    pub image_uri: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub link: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(rename = "networkId")]
    pub network_id: PortfolioNetworkId,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub r#ref: Option<PortfolioRef>,
    #[serde(rename = "sourceRefs", skip_serializing_if = "Option::is_none")]
    pub source_refs: Option<Vec<PortfolioSourceRef>>,
    pub value: f64,
}
#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize, Default)]
pub enum PortfolioPortfolioAssetTokenType {
    #[default]
    #[serde(rename = "token")]
    Token,
}
impl PortfolioPortfolioAssetTokenType {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::Token => "token",
        }
    }
}
impl ::std::fmt::Display for PortfolioPortfolioAssetTokenType {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        f.write_str(self.as_str())
    }
}
impl AsRef<str> for PortfolioPortfolioAssetTokenType {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PortfolioPortfolioAssetTokenData {
    pub address: String,
    pub amount: f64,
    pub price: f64,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub yields: Option<Vec<PortfolioYield>>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PortfolioPortfolioAssetGeneric {
    pub attributes: PortfolioPortfolioAssetAttributes,
    pub data: PortfolioPortfolioAssetGenericData,
    #[serde(rename = "imageUri", skip_serializing_if = "Option::is_none")]
    pub image_uri: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub link: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(rename = "networkId")]
    pub network_id: PortfolioNetworkId,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub r#ref: Option<PortfolioRef>,
    #[serde(rename = "sourceRefs", skip_serializing_if = "Option::is_none")]
    pub source_refs: Option<Vec<PortfolioSourceRef>>,
    pub value: f64,
}
#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize, Default)]
pub enum PortfolioPortfolioAssetGenericType {
    #[default]
    #[serde(rename = "generic")]
    Generic,
}
impl PortfolioPortfolioAssetGenericType {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::Generic => "generic",
        }
    }
}
impl ::std::fmt::Display for PortfolioPortfolioAssetGenericType {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        f.write_str(self.as_str())
    }
}
impl AsRef<str> for PortfolioPortfolioAssetGenericType {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct PortfolioPortfolioAssetGenericData {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub address: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub amount: Option<f64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub price: Option<f64>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PortfolioPortfolioAssetCollectible {
    pub attributes: PortfolioPortfolioAssetAttributes,
    pub data: PortfolioPortfolioAssetCollectibleData,
    #[serde(rename = "imageUri", skip_serializing_if = "Option::is_none")]
    pub image_uri: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub link: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(rename = "networkId")]
    pub network_id: PortfolioNetworkId,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub r#ref: Option<PortfolioRef>,
    #[serde(rename = "sourceRefs", skip_serializing_if = "Option::is_none")]
    pub source_refs: Option<Vec<PortfolioSourceRef>>,
    pub value: f64,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PortfolioSourceRef {
    pub address: String,
    pub name: PortfolioSourceRefName,
}
#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize, Default)]
pub enum PortfolioSourceRefName {
    #[default]
    #[serde(rename = "Pool")]
    Pool,
    #[serde(rename = "Farm")]
    Farm,
    #[serde(rename = "Market")]
    Market,
    #[serde(rename = "Vault")]
    Vault,
    #[serde(rename = "Lending Market")]
    LendingMarket,
    #[serde(rename = "Strategy")]
    Strategy,
    #[serde(rename = "NFT Mint")]
    NftMint,
    #[serde(rename = "Reserve")]
    Reserve,
    #[serde(rename = "Proposal")]
    Proposal,
    #[serde(rename = "Distributor")]
    Distributor,
    #[serde(rename = "Locker")]
    Locker,
    #[serde(rename = "Custody")]
    Custody,
    #[serde(rename = "Pair")]
    Pair,
    #[serde(rename = "Borrow Token")]
    BorrowToken,
    #[serde(rename = "Collateral Token")]
    CollateralToken,
    #[serde(rename = "Elevation Group")]
    ElevationGroup,
    #[serde(rename = "Program")]
    Program,
    #[serde(rename = "Validator")]
    Validator,
}
impl PortfolioSourceRefName {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::Pool => "Pool",
            Self::Farm => "Farm",
            Self::Market => "Market",
            Self::Vault => "Vault",
            Self::LendingMarket => "Lending Market",
            Self::Strategy => "Strategy",
            Self::NftMint => "NFT Mint",
            Self::Reserve => "Reserve",
            Self::Proposal => "Proposal",
            Self::Distributor => "Distributor",
            Self::Locker => "Locker",
            Self::Custody => "Custody",
            Self::Pair => "Pair",
            Self::BorrowToken => "Borrow Token",
            Self::CollateralToken => "Collateral Token",
            Self::ElevationGroup => "Elevation Group",
            Self::Program => "Program",
            Self::Validator => "Validator",
        }
    }
}
impl ::std::fmt::Display for PortfolioSourceRefName {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        f.write_str(self.as_str())
    }
}
impl AsRef<str> for PortfolioSourceRefName {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}
///Account address
pub type PortfolioRef = String;
#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize, Default)]
pub enum PortfolioPortfolioAssetCollectibleType {
    #[default]
    #[serde(rename = "collectible")]
    Collectible,
}
impl PortfolioPortfolioAssetCollectibleType {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::Collectible => "collectible",
        }
    }
}
impl ::std::fmt::Display for PortfolioPortfolioAssetCollectibleType {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        f.write_str(self.as_str())
    }
}
impl AsRef<str> for PortfolioPortfolioAssetCollectibleType {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PortfolioPortfolioAssetCollectibleData {
    pub address: String,
    pub amount: f64,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub attributes: Option<Vec<PortfolioCollectibleAttribute>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub collection: Option<PortfolioCollectibleCollection>,
    #[serde(rename = "dataUri", skip_serializing_if = "Option::is_none")]
    pub data_uri: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    #[serde(rename = "imageUri", skip_serializing_if = "Option::is_none")]
    pub image_uri: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    pub price: f64,
}
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct PortfolioPortfolioAssetAttributes {
    #[serde(rename = "isClaimable", skip_serializing_if = "Option::is_none")]
    pub is_claimable: Option<bool>,
    #[serde(rename = "isDeprecated", skip_serializing_if = "Option::is_none")]
    pub is_deprecated: Option<bool>,
    ///Date (in ms) when the asset will be unlocked. -1 means locked for an unknown period
    #[serde(rename = "lockedUntil", skip_serializing_if = "Option::is_none")]
    pub locked_until: Option<f64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub prediction: Option<PortfolioPortfolioAssetAttributesPrediction>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tags: Option<PortfolioTags>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub validator: Option<PortfolioPortfolioAssetAttributesValidator>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PortfolioPortfolioAssetAttributesValidator {
    pub address: String,
    #[serde(rename = "imageUri", skip_serializing_if = "Option::is_none")]
    pub image_uri: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    pub yields: Vec<PortfolioYield>,
}
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct PortfolioYield {
    ///Annual Percentage Rate as a fraction
    #[serde(skip_serializing_if = "Option::is_none")]
    pub apr: Option<f64>,
    ///Annual Percentage Yield as a fraction (0.28 = 28%)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub apy: Option<f64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
}
pub type PortfolioTags = Vec<String>;
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PortfolioPortfolioAssetAttributesPrediction {
    ///Timestamp in milliseconds
    #[serde(rename = "createdAt", skip_serializing_if = "Option::is_none")]
    pub created_at: Option<f64>,
    #[serde(rename = "feesPaidValue", skip_serializing_if = "Option::is_none")]
    pub fees_paid_value: Option<f64>,
    pub market: PortfolioPortfolioAssetAttributesMarket,
    #[serde(
        rename = "pnlAfterFeesPercent",
        skip_serializing_if = "Option::is_none"
    )]
    pub pnl_after_fees_percent: Option<f64>,
    #[serde(rename = "pnlAfterFeesValue", skip_serializing_if = "Option::is_none")]
    pub pnl_after_fees_value: Option<f64>,
    #[serde(rename = "pnlPercent", skip_serializing_if = "Option::is_none")]
    pub pnl_percent: Option<f64>,
    #[serde(rename = "pnlValue", skip_serializing_if = "Option::is_none")]
    pub pnl_value: Option<f64>,
    #[serde(rename = "sideName")]
    pub side_name: String,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PortfolioPortfolioAssetAttributesMarket {
    ///Timestamp in milliseconds
    #[serde(rename = "closeTime", skip_serializing_if = "Option::is_none")]
    pub close_time: Option<f64>,
    #[serde(rename = "eventTitle", skip_serializing_if = "Option::is_none")]
    pub event_title: Option<String>,
    #[serde(rename = "marketTitle")]
    pub market_title: String,
    ///Timestamp in milliseconds
    #[serde(rename = "resolveAt", skip_serializing_if = "Option::is_none")]
    pub resolve_at: Option<f64>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PortfolioCollectibleCollection {
    #[serde(rename = "floorPrice")]
    pub floor_price: f64,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub id: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
}
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct PortfolioCollectibleAttribute {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub trait_type: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub value: Option<serde_json::Value>,
    /// Additional properties not explicitly defined in the schema
    #[serde(flatten)]
    pub additional_properties: std::collections::BTreeMap<String, serde_json::Value>,
}
#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize, Default)]
pub enum PortfolioNetworkId {
    #[default]
    #[serde(rename = "solana")]
    Solana,
}
impl PortfolioNetworkId {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::Solana => "solana",
        }
    }
}
impl ::std::fmt::Display for PortfolioNetworkId {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        f.write_str(self.as_str())
    }
}
impl AsRef<str> for PortfolioNetworkId {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}
///Net APY (Annual Percentage Yield) as fraction. 0.28 means 28% APY
pub type PortfolioNetApy = f64;
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PortfolioFetcherReport {
    ///Execution duration in milliseconds
    #[serde(skip_serializing_if = "Option::is_none")]
    pub duration: Option<f64>,
    ///Error message if status is failed
    #[serde(skip_serializing_if = "Option::is_none")]
    pub error: Option<String>,
    ///Unique identifier of the fetcher
    pub id: String,
    ///Status of the fetcher execution
    pub status: PortfolioFetcherReportStatus,
}
///Status of the fetcher execution
#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize, Default)]
pub enum PortfolioFetcherReportStatus {
    #[default]
    #[serde(rename = "succeeded")]
    Succeeded,
    #[serde(rename = "failed")]
    Failed,
}
impl PortfolioFetcherReportStatus {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::Succeeded => "succeeded",
            Self::Failed => "failed",
        }
    }
}
impl ::std::fmt::Display for PortfolioFetcherReportStatus {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        f.write_str(self.as_str())
    }
}
impl AsRef<str> for PortfolioFetcherReportStatus {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}
pub type GetPortfolioV1PlatformsResponse = Vec<GetPortfolioV1PlatformsResponseItem>;
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct GetPortfolioV1PlatformsResponseItem {
    #[serde(rename = "defiLlamaId", skip_serializing_if = "Option::is_none")]
    pub defi_llama_id: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub id: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub image: Option<String>,
    #[serde(rename = "isDeprecated", skip_serializing_if = "Option::is_none")]
    pub is_deprecated: Option<bool>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub links: Option<GetPortfolioV1PlatformsResponseLinks>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub name: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tags: Option<Vec<String>>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub tokens: Option<Vec<String>>,
}
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct GetPortfolioV1PlatformsResponseLinks {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub discord: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub documentation: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub github: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub medium: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub telegram: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub twitter: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub website: Option<String>,
}
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct GetOrderResponse {
    ///Duplicate of errorMessage for backwards compatibility
    #[serde(skip_serializing_if = "Option::is_none")]
    pub error: Option<String>,
    /**Present when `taker` is defined and `transaction` is the empty string. The router quoted a price but could not build a transaction. Match on `router` + `errorCode` to identify the error.

    Aggregator routers (router is metis, dflow, okx):
    - 1: Insufficient funds
    - 2: Insufficient SOL for gas
    - 3: Swap below minimum for gasless

    JupiterZ router (router is jupiterz):
    - 1: Insufficient balance to fund the swap
    - 2: Missing associated token account
    - 3: Quote could not be built into a transaction
    */
    #[serde(rename = "errorCode", skip_serializing_if = "Option::is_none")]
    pub error_code: Option<f64>,
    /**Human-readable error description. Present when `taker` is defined and `transaction` is the empty string.
    Match on `router` + `errorCode` instead of this string, as the message text may be parameterised.
    */
    #[serde(rename = "errorMessage", skip_serializing_if = "Option::is_none")]
    pub error_message: Option<String>,
    ///Quote expiration timestamp for RFQ swaps
    #[serde(rename = "expireAt", skip_serializing_if = "Option::is_none")]
    pub expire_at: Option<String>,
    ///Total fee rate charged for the swap in basis points. This includes the Jupiter platform fee plus any additional charges, such as gasless support cost recoup.
    #[serde(rename = "feeBps", skip_serializing_if = "Option::is_none")]
    pub fee_bps: Option<f64>,
    #[serde(rename = "feeMint", skip_serializing_if = "Option::is_none")]
    pub fee_mint: Option<String>,
    /**True when signature and priority fees are paid by a wallet other than the taker. Set by three independent paths:
    - Automatic Jupiter sponsorship: `signatureFeePayer = gasTzr94Pmp4Gf8vknQnqxeYxdgwFjbgdJa4msYRpnB`
    - JupiterZ market maker: `signatureFeePayer` is the MM address (varies per quote); Jupiter's gas wallet can pay the rent to create the taker's output token account when referral fees are not set
    - Integrator payer: `signatureFeePayer` is your `payer` parameter
    For a deterministic opt-out, check `signatureFeePayer == taker` on every response.
    */
    #[serde(skip_serializing_if = "Option::is_none")]
    pub gasless: Option<bool>,
    #[serde(rename = "inAmount", skip_serializing_if = "Option::is_none")]
    pub in_amount: Option<String>,
    #[serde(rename = "inUsdValue", skip_serializing_if = "Option::is_none")]
    pub in_usd_value: Option<f64>,
    #[serde(rename = "inputMint", skip_serializing_if = "Option::is_none")]
    pub input_mint: Option<String>,
    #[serde(
        rename = "lastValidBlockHeight",
        skip_serializing_if = "Option::is_none"
    )]
    pub last_valid_block_height: Option<String>,
    ///Market maker address for RFQ swaps
    #[serde(skip_serializing_if = "Option::is_none")]
    pub maker: Option<String>,
    ///"ultra" or "manual" based on parameters used
    #[serde(skip_serializing_if = "Option::is_none")]
    pub mode: Option<String>,
    ///Minimum output amount after slippage
    #[serde(
        rename = "otherAmountThreshold",
        skip_serializing_if = "Option::is_none"
    )]
    pub other_amount_threshold: Option<String>,
    #[serde(rename = "outAmount", skip_serializing_if = "Option::is_none")]
    pub out_amount: Option<String>,
    #[serde(rename = "outUsdValue", skip_serializing_if = "Option::is_none")]
    pub out_usd_value: Option<f64>,
    #[serde(rename = "outputMint", skip_serializing_if = "Option::is_none")]
    pub output_mint: Option<String>,
    #[serde(rename = "platformFee", skip_serializing_if = "Option::is_none")]
    pub platform_fee: Option<SwapV2PlatformFee>,
    ///Price impact in percentage points (e.g. -0.1 = -0.1%). Divide by 100 to convert to a decimal fraction.
    #[serde(rename = "priceImpact", skip_serializing_if = "Option::is_none")]
    pub price_impact: Option<f64>,
    ///Deprecated: decimal price impact ratio. Use priceImpact divided by 100 instead.
    #[serde(rename = "priceImpactPct", skip_serializing_if = "Option::is_none")]
    pub price_impact_pct: Option<String>,
    ///Includes priority fees and tips (Jito, Nozomi)
    #[serde(
        rename = "prioritizationFeeLamports",
        skip_serializing_if = "Option::is_none"
    )]
    pub prioritization_fee_lamports: Option<f64>,
    #[serde(
        rename = "prioritizationFeePayer",
        skip_serializing_if = "Option::is_none"
    )]
    pub prioritization_fee_payer: Option<String>,
    ///Quote ID for RFQ swaps
    #[serde(rename = "quoteId", skip_serializing_if = "Option::is_none")]
    pub quote_id: Option<String>,
    #[serde(rename = "referralAccount", skip_serializing_if = "Option::is_none")]
    pub referral_account: Option<String>,
    ///Estimated rent fee
    #[serde(rename = "rentFeeLamports", skip_serializing_if = "Option::is_none")]
    pub rent_fee_lamports: Option<f64>,
    #[serde(rename = "rentFeePayer", skip_serializing_if = "Option::is_none")]
    pub rent_fee_payer: Option<String>,
    ///Unique request ID. Pass this to /execute.
    #[serde(rename = "requestId", skip_serializing_if = "Option::is_none")]
    pub request_id: Option<String>,
    #[serde(rename = "routePlan", skip_serializing_if = "Option::is_none")]
    pub route_plan: Option<Vec<SwapV2RoutePlanStep>>,
    ///Which router won the quote
    #[serde(skip_serializing_if = "Option::is_none")]
    pub router: Option<GetOrderResponseRouter>,
    #[serde(
        rename = "signatureFeeLamports",
        skip_serializing_if = "Option::is_none"
    )]
    pub signature_fee_lamports: Option<f64>,
    #[serde(rename = "signatureFeePayer", skip_serializing_if = "Option::is_none")]
    pub signature_fee_payer: Option<String>,
    #[serde(rename = "slippageBps", skip_serializing_if = "Option::is_none")]
    pub slippage_bps: Option<f64>,
    #[serde(rename = "swapMode", skip_serializing_if = "Option::is_none")]
    pub swap_mode: Option<String>,
    ///Deprecated: use router instead
    #[serde(rename = "swapType", skip_serializing_if = "Option::is_none")]
    pub swap_type: Option<GetOrderResponseSwapType>,
    #[serde(rename = "swapUsdValue", skip_serializing_if = "Option::is_none")]
    pub swap_usd_value: Option<f64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub taker: Option<String>,
    ///Response time in milliseconds
    #[serde(rename = "totalTime", skip_serializing_if = "Option::is_none")]
    pub total_time: Option<f64>,
    /**- Base64-encoded transaction. Null if taker is not provided.
    - Empty string if taker is provided but transaction could not be built (check errorCode).
    */
    #[serde(skip_serializing_if = "Option::is_none")]
    pub transaction: Option<String>,
}
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct SwapV2PlatformFee {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub amount: Option<String>,
    ///Jupiter platform fee component in basis points. This is the fee Jupiter intends to make from the swap and does not include gasless support cost recoup.
    #[serde(rename = "feeBps", skip_serializing_if = "Option::is_none")]
    pub fee_bps: Option<f64>,
    #[serde(rename = "feeMint", skip_serializing_if = "Option::is_none")]
    pub fee_mint: Option<String>,
}
///Deprecated: use router instead
#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize, Default)]
pub enum GetOrderResponseSwapType {
    #[default]
    #[serde(rename = "aggregator")]
    Aggregator,
    #[serde(rename = "rfq")]
    Rfq,
    #[serde(rename = "aggregator+rfq")]
    AggregatorRfq,
    #[serde(rename = "dflow")]
    Dflow,
    #[serde(rename = "okx")]
    Okx,
}
impl GetOrderResponseSwapType {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::Aggregator => "aggregator",
            Self::Rfq => "rfq",
            Self::AggregatorRfq => "aggregator+rfq",
            Self::Dflow => "dflow",
            Self::Okx => "okx",
        }
    }
}
impl ::std::fmt::Display for GetOrderResponseSwapType {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        f.write_str(self.as_str())
    }
}
impl AsRef<str> for GetOrderResponseSwapType {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}
///Which router won the quote
#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize, Default)]
pub enum GetOrderResponseRouter {
    #[default]
    #[serde(rename = "metis")]
    Metis,
    #[serde(rename = "jupiterz")]
    Jupiterz,
    #[serde(rename = "dflow")]
    Dflow,
    #[serde(rename = "okx")]
    Okx,
}
impl GetOrderResponseRouter {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::Metis => "metis",
            Self::Jupiterz => "jupiterz",
            Self::Dflow => "dflow",
            Self::Okx => "okx",
        }
    }
}
impl ::std::fmt::Display for GetOrderResponseRouter {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        f.write_str(self.as_str())
    }
}
impl AsRef<str> for GetOrderResponseRouter {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct GetBuildResponse {
    ///Address lookup table mappings for v0 transactions
    #[serde(
        rename = "addressesByLookupTableAddress",
        skip_serializing_if = "Option::is_none"
    )]
    pub addresses_by_lookup_table_address: Option<GetBuildResponseAddressesByLookupTableAddress>,
    #[serde(
        rename = "blockhashWithMetadata",
        skip_serializing_if = "Option::is_none"
    )]
    pub blockhash_with_metadata: Option<GetBuildResponseBlockhashWithMetadata>,
    #[serde(rename = "cleanupInstruction", skip_serializing_if = "Option::is_none")]
    pub cleanup_instruction: Option<SwapV2Instruction>,
    ///Compute unit price instruction (does not include compute unit limit)
    #[serde(
        rename = "computeBudgetInstructions",
        skip_serializing_if = "Option::is_none"
    )]
    pub compute_budget_instructions: Option<Vec<SwapV2Instruction>>,
    #[serde(rename = "inAmount", skip_serializing_if = "Option::is_none")]
    pub in_amount: Option<String>,
    #[serde(rename = "inputMint", skip_serializing_if = "Option::is_none")]
    pub input_mint: Option<String>,
    ///Minimum output amount after slippage
    #[serde(
        rename = "otherAmountThreshold",
        skip_serializing_if = "Option::is_none"
    )]
    pub other_amount_threshold: Option<String>,
    #[serde(rename = "otherInstructions", skip_serializing_if = "Option::is_none")]
    pub other_instructions: Option<Vec<SwapV2Instruction>>,
    #[serde(rename = "outAmount", skip_serializing_if = "Option::is_none")]
    pub out_amount: Option<String>,
    #[serde(rename = "outputMint", skip_serializing_if = "Option::is_none")]
    pub output_mint: Option<String>,
    #[serde(rename = "routePlan", skip_serializing_if = "Option::is_none")]
    pub route_plan: Option<Vec<SwapV2RoutePlanStep>>,
    ///Pre-swap setup instructions (e.g. create ATAs)
    #[serde(rename = "setupInstructions", skip_serializing_if = "Option::is_none")]
    pub setup_instructions: Option<Vec<SwapV2Instruction>>,
    #[serde(rename = "slippageBps", skip_serializing_if = "Option::is_none")]
    pub slippage_bps: Option<f64>,
    #[serde(rename = "swapInstruction", skip_serializing_if = "Option::is_none")]
    pub swap_instruction: Option<SwapV2Instruction>,
    #[serde(rename = "swapMode", skip_serializing_if = "Option::is_none")]
    pub swap_mode: Option<String>,
    #[serde(rename = "tipInstruction", skip_serializing_if = "Option::is_none")]
    pub tip_instruction: Option<SwapV2Instruction>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct SwapV2RoutePlanStep {
    ///Basis points of total swap routed through this step
    pub bps: f64,
    ///Percentage of total swap routed through this step
    pub percent: f64,
    #[serde(rename = "swapInfo")]
    pub swap_info: SwapV2SwapInfo,
    ///USD value of this step
    #[serde(rename = "usdValue", skip_serializing_if = "Option::is_none")]
    pub usd_value: Option<f64>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct SwapV2SwapInfo {
    #[serde(rename = "ammKey")]
    pub amm_key: String,
    #[serde(rename = "inAmount")]
    pub in_amount: String,
    #[serde(rename = "inputMint")]
    pub input_mint: String,
    pub label: String,
    #[serde(rename = "outAmount")]
    pub out_amount: String,
    #[serde(rename = "outputMint")]
    pub output_mint: String,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct SwapV2Instruction {
    pub accounts: Vec<SwapV2InstructionAccountsItem>,
    ///Base64-encoded instruction data
    pub data: String,
    ///Program executing the instruction
    #[serde(rename = "programId")]
    pub program_id: String,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct SwapV2InstructionAccountsItem {
    #[serde(rename = "isSigner")]
    pub is_signer: bool,
    #[serde(rename = "isWritable")]
    pub is_writable: bool,
    pub pubkey: String,
}
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct GetBuildResponseBlockhashWithMetadata {
    ///Blockhash as byte array
    #[serde(skip_serializing_if = "Option::is_none")]
    pub blockhash: Option<Vec<f64>>,
    ///ISO 8601 timestamp of when the blockhash was fetched
    #[serde(rename = "fetchedAt", skip_serializing_if = "Option::is_none")]
    pub fetched_at: Option<String>,
    #[serde(
        rename = "lastValidBlockHeight",
        skip_serializing_if = "Option::is_none"
    )]
    pub last_valid_block_height: Option<f64>,
}
///Address lookup table mappings for v0 transactions
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct GetBuildResponseAddressesByLookupTableAddress {
    /// Additional properties matching the spec's
    /// `additionalProperties` value schema.
    #[serde(flatten)]
    pub additional_properties: std::collections::BTreeMap<String, Vec<String>>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct DeletePredictionV1PositionsResponse {
    pub data: Vec<DeletePredictionV1PositionsResponseDataItemUnion>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(untagged)]
pub enum DeletePredictionV1PositionsResponseDataItemUnion {
    PredictionCreateOrderResponse(PredictionCreateOrderResponse),
    PredictionClaimPositionResponse(PredictionClaimPositionResponse),
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PredictionCreateOrderResponse {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub execution: Option<PredictionExecution>,
    ///Execution model for the order. `atomic_swap` for Jupiter Forecast (bisonfi) orders, which execute as a single atomic swap through `POST /execute`. `null` for keeper-filled prediction orders.
    #[serde(rename = "executionModel", skip_serializing_if = "Option::is_none")]
    pub execution_model: Option<String>,
    #[serde(rename = "externalOrderId", skip_serializing_if = "Option::is_none")]
    pub external_order_id: Option<String>,
    ///Jupiter swap request id when the order executes as a swap (Jupiter Forecast). `null` otherwise.
    #[serde(
        rename = "jupiterSwapRequestId",
        skip_serializing_if = "Option::is_none"
    )]
    pub jupiter_swap_request_id: Option<String>,
    pub order: PredictionCreateOrderResponseOrder,
    ///Public keys that must sign the returned transaction
    #[serde(rename = "requiredSigners", skip_serializing_if = "Option::is_none")]
    pub required_signers: Option<Vec<String>>,
    ///Settlement mode. `auto` for Jupiter Forecast orders, which settle automatically. `null` for keeper-filled prediction orders.
    #[serde(skip_serializing_if = "Option::is_none")]
    pub settlement: Option<String>,
    ///Base64 encoded transaction
    #[serde(skip_serializing_if = "Option::is_none")]
    pub transaction: Option<String>,
    ///Transaction metadata
    #[serde(rename = "txMeta", skip_serializing_if = "Option::is_none")]
    pub tx_meta: Option<PredictionCreateOrderResponseTxMeta>,
}
///Transaction metadata
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PredictionCreateOrderResponseTxMeta {
    pub blockhash: String,
    ///Constraint: minimum=0
    #[serde(rename = "lastValidBlockHeight")]
    pub last_valid_block_height: i64,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PredictionCreateOrderResponseOrder {
    ///Legacy whole-contract quantity. Use contractsMicro or contractsDecimal for the exact fractional quantity.
    pub contracts: String,
    ///Contracts as a decimal string
    #[serde(rename = "contractsDecimal", skip_serializing_if = "Option::is_none")]
    pub contracts_decimal: Option<String>,
    ///Contracts in micro-contract units (u64 as string, 1000000 = 1 contract)
    #[serde(rename = "contractsMicro", skip_serializing_if = "Option::is_none")]
    pub contracts_micro: Option<String>,
    ///Estimated protocol fee (micro USD)
    #[serde(rename = "estimatedProtocolFeeUsd")]
    pub estimated_protocol_fee_usd: String,
    ///Estimated total fees applied (micro USD)
    #[serde(rename = "estimatedTotalFeeUsd")]
    pub estimated_total_fee_usd: String,
    ///Estimated venue fee (micro USD)
    #[serde(rename = "estimatedVenueFeeUsd")]
    pub estimated_venue_fee_usd: String,
    ///Client provided order identifier
    #[serde(rename = "externalOrderId", skip_serializing_if = "Option::is_none")]
    pub external_order_id: Option<String>,
    ///True when the order increases exposure
    #[serde(rename = "isBuy")]
    pub is_buy: bool,
    ///True when the order is on the YES side
    #[serde(rename = "isYes")]
    pub is_yes: bool,
    ///Associated market identifier
    #[serde(rename = "marketId")]
    pub market_id: String,
    ///Hashed market identifier used for on-chain PDAs
    #[serde(rename = "marketIdHash")]
    pub market_id_hash: String,
    ///Max fill price for buys (micro USD)
    #[serde(rename = "maxBuyPriceUsd", skip_serializing_if = "Option::is_none")]
    pub max_buy_price_usd: Option<String>,
    ///Maximum slippage allowed for this order, in basis points
    ///Constraint: minimum=0
    #[serde(rename = "maxSlippageBps", skip_serializing_if = "Option::is_none")]
    pub max_slippage_bps: Option<i64>,
    ///Min fill price for sells (micro USD)
    #[serde(rename = "minSellPriceUsd", skip_serializing_if = "Option::is_none")]
    pub min_sell_price_usd: Option<String>,
    ///Average position entry price after the order
    #[serde(rename = "newAvgPriceUsd")]
    pub new_avg_price_usd: String,
    ///Position contracts after executing the order (legacy whole-contract quantity)
    #[serde(rename = "newContracts")]
    pub new_contracts: String,
    ///Position contracts after the order, as a decimal string
    #[serde(
        rename = "newContractsDecimal",
        skip_serializing_if = "Option::is_none"
    )]
    pub new_contracts_decimal: Option<String>,
    ///Position contracts after the order, in micro-contract units
    #[serde(rename = "newContractsMicro", skip_serializing_if = "Option::is_none")]
    pub new_contracts_micro: Option<String>,
    ///Position max payout after the order
    #[serde(rename = "newPayoutUsd")]
    pub new_payout_usd: String,
    ///Total position cost basis after the order
    #[serde(rename = "newSizeUsd")]
    pub new_size_usd: String,
    ///Order escrow token account
    #[serde(rename = "orderAtaPubkey", skip_serializing_if = "Option::is_none")]
    pub order_ata_pubkey: Option<String>,
    ///Notional for this order in micro USD
    #[serde(rename = "orderCostUsd")]
    pub order_cost_usd: String,
    ///Order account public key
    #[serde(rename = "orderPubkey", skip_serializing_if = "Option::is_none")]
    pub order_pubkey: Option<String>,
    ///Position max payout for this order (micro USD)
    #[serde(rename = "payoutUsd", skip_serializing_if = "Option::is_none")]
    pub payout_usd: Option<String>,
    ///Position PDA used for the order
    #[serde(rename = "positionPubkey")]
    pub position_pubkey: String,
    ///Estimated slippage for this order, in basis points (0 = none, 250 = 2.5%). For a Polymarket buy this is the estimated price impact from sweeping orderbook levels; for a sell it is the max allowed slippage from best bid to the protected sell floor. Treat it as a quote signal, not a guaranteed loss.
    ///Constraint: minimum=0
    #[serde(rename = "slippageBps", skip_serializing_if = "Option::is_none")]
    pub slippage_bps: Option<i64>,
    ///Order owner public key
    #[serde(rename = "userPubkey")]
    pub user_pubkey: String,
}
///Execution details returned with an order build. Sign the build's `transaction`, then pass `context` unchanged to `POST /execute`.
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PredictionExecution {
    ///Opaque execution context. Pass this object unchanged to `POST /execute`. Includes a `type` field (`create_order` for keeper-filled orders, `bisonfi_swap` for Jupiter Forecast orders).
    pub context: PredictionExecutionContext,
    ///Relative execute path. Resolves to `https://api.jup.ag/prediction/v1/execute`.
    pub endpoint: String,
}
///Opaque execution context. Pass this object unchanged to `POST /execute`. Includes a `type` field (`create_order` for keeper-filled orders, `bisonfi_swap` for Jupiter Forecast orders).
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct PredictionExecutionContext {
    /// Additional properties not explicitly defined in the schema
    #[serde(flatten)]
    pub additional_properties: std::collections::BTreeMap<String, serde_json::Value>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PredictionClaimPositionResponse {
    pub position: PredictionClaimPositionResponsePosition,
    ///Base64 encoded transaction
    pub transaction: String,
    #[serde(rename = "txMeta")]
    pub tx_meta: PredictionClaimPositionResponseTxMeta,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PredictionClaimPositionResponseTxMeta {
    pub blockhash: String,
    ///Constraint: minimum=0
    #[serde(rename = "lastValidBlockHeight")]
    pub last_valid_block_height: i64,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PredictionClaimPositionResponsePosition {
    ///Legacy whole-contract quantity settled. Use contractsMicro or contractsDecimal for the exact fractional quantity.
    pub contracts: String,
    ///Contracts settled as a decimal string
    #[serde(rename = "contractsDecimal", skip_serializing_if = "Option::is_none")]
    pub contracts_decimal: Option<String>,
    ///Contracts settled in micro-contract units (u64 as string, 1000000 = 1 contract)
    #[serde(rename = "contractsMicro", skip_serializing_if = "Option::is_none")]
    pub contracts_micro: Option<String>,
    #[serde(rename = "isYes")]
    pub is_yes: bool,
    ///Market account public key
    #[serde(rename = "marketPubkey")]
    pub market_pubkey: String,
    ///Position owner public key
    #[serde(rename = "ownerPubkey")]
    pub owner_pubkey: String,
    ///Payout amount in micro USD (u64 as string)
    #[serde(rename = "payoutAmountUsd")]
    pub payout_amount_usd: String,
    ///Position account public key
    #[serde(rename = "positionPubkey")]
    pub position_pubkey: String,
    ///User public key requesting claim
    #[serde(rename = "userPubkey")]
    pub user_pubkey: String,
}
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct ArrayItemItem {
    /**- Human-readable warning message
     */
    #[serde(skip_serializing_if = "Option::is_none")]
    pub message: Option<String>,
    /**- Severity level of the warning
     */
    #[serde(skip_serializing_if = "Option::is_none")]
    pub severity: Option<GetUltraV1ShieldResponseSeverity>,
    /**- Optional external source of the warning
     */
    #[serde(skip_serializing_if = "Option::is_none")]
    pub source: Option<GetUltraV1ShieldResponseSource>,
    /**- Type of warning for the token
     */
    #[serde(skip_serializing_if = "Option::is_none")]
    pub r#type: Option<GetUltraV1ShieldResponseType>,
}
/**- Type of warning for the token
*/
#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize, Default)]
pub enum GetUltraV1ShieldResponseType {
    #[default]
    #[serde(rename = "NOT_VERIFIED")]
    NotVerified,
    #[serde(rename = "LOW_LIQUIDITY")]
    LowLiquidity,
    #[serde(rename = "NOT_SELLABLE")]
    NotSellable,
    #[serde(rename = "LOW_ORGANIC_ACTIVITY")]
    LowOrganicActivity,
    #[serde(rename = "HAS_MINT_AUTHORITY")]
    HasMintAuthority,
    #[serde(rename = "HAS_FREEZE_AUTHORITY")]
    HasFreezeAuthority,
    #[serde(rename = "HAS_PERMANENT_DELEGATE")]
    HasPermanentDelegate,
    #[serde(rename = "NEW_LISTING")]
    NewListing,
    #[serde(rename = "VERY_LOW_TRADING_ACTIVITY")]
    VeryLowTradingActivity,
    #[serde(rename = "HIGH_SUPPLY_CONCENTRATION")]
    HighSupplyConcentration,
    #[serde(rename = "NON_TRANSFERABLE")]
    NonTransferable,
    #[serde(rename = "MUTABLE_TRANSFER_FEES")]
    MutableTransferFees,
    #[serde(rename = "SUSPICIOUS_DEV_ACTIVITY")]
    SuspiciousDevActivity,
    #[serde(rename = "SUSPICIOUS_TOP_HOLDER_ACTIVITY")]
    SuspiciousTopHolderActivity,
    #[serde(rename = "HIGH_SINGLE_OWNERSHIP")]
    HighSingleOwnership,
    #[serde(rename = "{}%_TRANSFER_FEES")]
    TransferFees,
}
impl GetUltraV1ShieldResponseType {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::NotVerified => "NOT_VERIFIED",
            Self::LowLiquidity => "LOW_LIQUIDITY",
            Self::NotSellable => "NOT_SELLABLE",
            Self::LowOrganicActivity => "LOW_ORGANIC_ACTIVITY",
            Self::HasMintAuthority => "HAS_MINT_AUTHORITY",
            Self::HasFreezeAuthority => "HAS_FREEZE_AUTHORITY",
            Self::HasPermanentDelegate => "HAS_PERMANENT_DELEGATE",
            Self::NewListing => "NEW_LISTING",
            Self::VeryLowTradingActivity => "VERY_LOW_TRADING_ACTIVITY",
            Self::HighSupplyConcentration => "HIGH_SUPPLY_CONCENTRATION",
            Self::NonTransferable => "NON_TRANSFERABLE",
            Self::MutableTransferFees => "MUTABLE_TRANSFER_FEES",
            Self::SuspiciousDevActivity => "SUSPICIOUS_DEV_ACTIVITY",
            Self::SuspiciousTopHolderActivity => "SUSPICIOUS_TOP_HOLDER_ACTIVITY",
            Self::HighSingleOwnership => "HIGH_SINGLE_OWNERSHIP",
            Self::TransferFees => "{}%_TRANSFER_FEES",
        }
    }
}
impl ::std::fmt::Display for GetUltraV1ShieldResponseType {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        f.write_str(self.as_str())
    }
}
impl AsRef<str> for GetUltraV1ShieldResponseType {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}
/**- Optional external source of the warning
*/
#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize, Default)]
pub enum GetUltraV1ShieldResponseSource {
    #[default]
    #[serde(rename = "RugCheck")]
    RugCheck,
}
impl GetUltraV1ShieldResponseSource {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::RugCheck => "RugCheck",
        }
    }
}
impl ::std::fmt::Display for GetUltraV1ShieldResponseSource {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        f.write_str(self.as_str())
    }
}
impl AsRef<str> for GetUltraV1ShieldResponseSource {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}
/**- Severity level of the warning
*/
#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize, Default)]
pub enum GetUltraV1ShieldResponseSeverity {
    #[default]
    #[serde(rename = "info")]
    Info,
    #[serde(rename = "warning")]
    Warning,
    #[serde(rename = "critical")]
    Critical,
}
impl GetUltraV1ShieldResponseSeverity {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::Info => "info",
            Self::Warning => "warning",
            Self::Critical => "critical",
        }
    }
}
impl ::std::fmt::Display for GetUltraV1ShieldResponseSeverity {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        f.write_str(self.as_str())
    }
}
impl AsRef<str> for GetUltraV1ShieldResponseSeverity {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct GetBuildResponse400 {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub error: Option<String>,
}
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct GetOrderResponse400 {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub error: Option<String>,
    #[serde(rename = "requestId", skip_serializing_if = "Option::is_none")]
    pub request_id: Option<String>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct GetPredictionV1OrderbookMarketIdResponse {
    ///NO-side levels sorted by price ascending. Each entry is a [price_cents, size] tuple. price_cents is rounded, so sub-cent levels show 0; size may be fractional.
    pub no: Vec<Vec<f64>>,
    ///NO-side levels with price as decimal dollar string. Each entry is a [price_string, size] tuple, e.g. ["0.0100", 219].
    pub no_dollars: Vec<Vec<serde_json::Value>>,
    ///YES-side levels sorted by price ascending. Each entry is a [price_cents, size] tuple. price_cents is rounded, so sub-cent levels show 0; size may be fractional.
    pub yes: Vec<Vec<f64>>,
    ///YES-side levels with price as decimal dollar string. Each entry is a [price_string, size] tuple, e.g. ["0.0100", 346014].
    pub yes_dollars: Vec<Vec<serde_json::Value>>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct GetPredictionV1ProfilesOwnerPubkeyResponse {
    #[serde(rename = "correctPredictions")]
    pub correct_predictions: String,
    #[serde(rename = "ownerPubkey")]
    pub owner_pubkey: String,
    #[serde(rename = "predictionsCount")]
    pub predictions_count: String,
    #[serde(rename = "realizedPnlUsd")]
    pub realized_pnl_usd: String,
    ///Legacy whole-contract count. Use totalActiveContractsMicro or totalActiveContractsDecimal for the exact value.
    #[serde(rename = "totalActiveContracts")]
    pub total_active_contracts: String,
    ///Active contracts as a decimal string
    #[serde(
        rename = "totalActiveContractsDecimal",
        skip_serializing_if = "Option::is_none"
    )]
    pub total_active_contracts_decimal: Option<String>,
    ///Active contracts in micro-contract units (1000000 = 1 contract)
    #[serde(
        rename = "totalActiveContractsMicro",
        skip_serializing_if = "Option::is_none"
    )]
    pub total_active_contracts_micro: Option<String>,
    #[serde(rename = "totalPositionsValueUsd")]
    pub total_positions_value_usd: String,
    #[serde(rename = "totalVolumeUsd")]
    pub total_volume_usd: String,
    #[serde(rename = "wrongPredictions")]
    pub wrong_predictions: String,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct GetPredictionV1ProfilesOwnerPubkeyResponse404 {
    pub error: String,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct GetPredictionV1VaultInfoResponse404 {
    pub error: String,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct GetSendV1InviteHistoryResponse400 {
    pub error: String,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct GetSendV1InviteHistoryResponse500 {
    pub error: String,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct GetSendV1PendingInvitesResponse400 {
    pub error: String,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct GetSendV1PendingInvitesResponse500 {
    pub error: String,
}
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct GetStudioV1DbcPoolAddressesMintResponse400 {
    ///Validation errors
    #[serde(skip_serializing_if = "Option::is_none")]
    pub errors: Option<serde_json::Value>,
}
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct GetStudioV1DbcPoolAddressesMintResponse404 {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub error: Option<String>,
}
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct GetStudioV1DbcPoolAddressesMintResponse500 {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub error: Option<String>,
}
pub type GetTokensV1MarketMarketAddressMintsResponse = Vec<String>;
pub type GetTokensV1MintsTradableResponse = Vec<String>;
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct GetTokensV2CategoryIntervalResponse400 {
    pub error: String,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct GetTokensV2CategoryIntervalResponse500 {
    pub error: String,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct GetTokensV2RecentResponse400 {
    pub error: String,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct GetTokensV2RecentResponse500 {
    pub error: String,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct GetTokensV2SearchResponse400 {
    pub error: String,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct GetTokensV2SearchResponse500 {
    pub error: String,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct GetTokensV2TagResponse400 {
    pub error: String,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct GetTokensV2TagResponse500 {
    pub error: String,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct GetTriggerV2VaultRegisterResponse201 {
    #[serde(rename = "privyVaultId")]
    pub privy_vault_id: String,
    #[serde(rename = "userPubkey")]
    pub user_pubkey: String,
    #[serde(rename = "vaultPubkey")]
    pub vault_pubkey: String,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct GetTriggerV2VaultResponse {
    #[serde(rename = "privyUserId", skip_serializing_if = "Option::is_none")]
    pub privy_user_id: Option<String>,
    #[serde(rename = "privyVaultId")]
    pub privy_vault_id: String,
    #[serde(rename = "userPubkey")]
    pub user_pubkey: String,
    #[serde(rename = "vaultPubkey")]
    pub vault_pubkey: String,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct GetUltraV1BalancesAddressResponse400 {
    pub error: String,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct GetUltraV1BalancesAddressResponse500 {
    pub error: String,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct GetUltraV1OrderResponse400 {
    pub error: String,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct GetUltraV1OrderResponse500 {
    pub error: String,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct GetUltraV1SearchResponse400 {
    pub error: String,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct GetUltraV1SearchResponse500 {
    pub error: String,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct GetUltraV1ShieldResponse400 {
    pub error: String,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct GetUltraV1ShieldResponse500 {
    pub error: String,
}
#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize, Default)]
pub enum LendBorrowMarket {
    #[default]
    #[serde(rename = "main")]
    Main,
    #[serde(rename = "ethena")]
    Ethena,
}
impl LendBorrowMarket {
    pub fn as_str(&self) -> &'static str {
        match self {
            Self::Main => "main",
            Self::Ethena => "ethena",
        }
    }
}
impl ::std::fmt::Display for LendBorrowMarket {
    fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
        f.write_str(self.as_str())
    }
}
impl AsRef<str> for LendBorrowMarket {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}
///Request body validated by `operateValidator` in `app/validators/borrowing.ts`.
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct LendBorrowOperatePayload {
    ///Collateral delta in supply-token base units. Positive deposits collateral, negative withdraws. Use -170141183460469231731687303715884105728 (MIN_I128) to withdraw all collateral.
    ///Constraint: pattern=`^-?[0-9]+$`
    #[serde(rename = "colAmount")]
    pub col_amount: String,
    ///Debt delta in borrow-token base units. Positive borrows, negative repays. Use -170141183460469231731687303715884105728 (MIN_I128) to repay all debt.
    ///Constraint: pattern=`^-?[0-9]+$`
    #[serde(rename = "debtAmount")]
    pub debt_amount: String,
    ///Existing position id. Use `0` when opening a new position.
    #[serde(rename = "positionId")]
    pub position_id: i64,
    ///Optional position owner when operating on behalf of another wallet.
    #[serde(rename = "positionOwner", skip_serializing_if = "Option::is_none")]
    pub position_owner: Option<String>,
    ///Transaction fee payer and signer wallet address.
    pub signer: String,
    ///Target vault id.
    #[serde(rename = "vaultId")]
    pub vault_id: i64,
}
impl LendBorrowOperatePayload {
    /// Construct this request with every required wire field.
    pub fn new(
        col_amount: String,
        debt_amount: String,
        position_id: i64,
        signer: String,
        vault_id: i64,
    ) -> Self {
        Self {
            col_amount,
            debt_amount,
            position_id,
            signer,
            vault_id,
            position_owner: None,
        }
    }
    /// Start a dependency-free builder with every required wire field.
    pub fn builder(
        col_amount: String,
        debt_amount: String,
        position_id: i64,
        signer: String,
        vault_id: i64,
    ) -> LendBorrowOperatePayloadBuilder {
        LendBorrowOperatePayloadBuilder::new(col_amount, debt_amount, position_id, signer, vault_id)
    }
}
/// Dependency-free builder for [`#struct_name`].
#[derive(Debug, Clone)]
#[must_use]
pub struct LendBorrowOperatePayloadBuilder {
    value: LendBorrowOperatePayload,
}
impl LendBorrowOperatePayloadBuilder {
    /// Start a builder with every required wire field.
    pub fn new(
        col_amount: String,
        debt_amount: String,
        position_id: i64,
        signer: String,
        vault_id: i64,
    ) -> Self {
        Self {
            value: LendBorrowOperatePayload::new(
                col_amount,
                debt_amount,
                position_id,
                signer,
                vault_id,
            ),
        }
    }
    #[doc = concat!("Set the optional `", "positionOwner", "` request field.")]
    #[must_use]
    pub fn position_owner(mut self, position_owner: String) -> Self {
        self.value.position_owner = Some(position_owner);
        self
    }
    /// Finish building the request model.
    pub fn build(self) -> LendBorrowOperatePayload {
        self.value
    }
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct LendBorrowOperateTransactionResponse {
    ///Position NFT id affected by the operation.
    #[serde(rename = "nftId")]
    pub nft_id: i64,
    ///Base64-encoded unsigned versioned transaction.
    pub transaction: String,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct LendEarnAmountRequestBody {
    #[serde(default)]
    pub amount: String,
    #[serde(default)]
    pub asset: String,
    #[serde(default)]
    pub signer: String,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct LendEarnSharesRequestBody {
    #[serde(default)]
    pub asset: String,
    #[serde(default)]
    pub shares: String,
    #[serde(default)]
    pub signer: String,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct LendTransactionResponse {
    pub transaction: String,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct LendUserEarningsResponse {
    pub address: String,
    pub earnings: f64,
    #[serde(rename = "ownerAddress")]
    pub owner_address: String,
    pub slot: f64,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PatchTriggerV2OrdersPriceOrderIdResponse {
    pub id: String,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PostExecuteRequest {
    ///Optional block height for nonce validation
    #[serde(
        rename = "lastValidBlockHeight",
        skip_serializing_if = "Option::is_none"
    )]
    pub last_valid_block_height: Option<String>,
    ///The requestId from the /order response
    #[serde(rename = "requestId")]
    pub request_id: String,
    ///Base64-encoded signed transaction
    #[serde(rename = "signedTransaction")]
    pub signed_transaction: String,
}
impl PostExecuteRequest {
    /// Construct this request with every required wire field.
    pub fn new(request_id: String, signed_transaction: String) -> Self {
        Self {
            request_id,
            signed_transaction,
            last_valid_block_height: None,
        }
    }
    /// Start a dependency-free builder with every required wire field.
    pub fn builder(request_id: String, signed_transaction: String) -> PostExecuteRequestBuilder {
        PostExecuteRequestBuilder::new(request_id, signed_transaction)
    }
}
/// Dependency-free builder for [`#struct_name`].
#[derive(Debug, Clone)]
#[must_use]
pub struct PostExecuteRequestBuilder {
    value: PostExecuteRequest,
}
impl PostExecuteRequestBuilder {
    /// Start a builder with every required wire field.
    pub fn new(request_id: String, signed_transaction: String) -> Self {
        Self {
            value: PostExecuteRequest::new(request_id, signed_transaction),
        }
    }
    #[doc = concat!("Set the optional `", "lastValidBlockHeight", "` request field.")]
    #[must_use]
    pub fn last_valid_block_height(mut self, last_valid_block_height: String) -> Self {
        self.value.last_valid_block_height = Some(last_valid_block_height);
        self
    }
    /// Finish building the request model.
    pub fn build(self) -> PostExecuteRequest {
        self.value
    }
}
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct PostExecuteResponse400 {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub code: Option<f64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub error: Option<String>,
}
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct PostExecuteResponse500 {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub error: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub signature: Option<String>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PostSendV1CraftClawbackRequest {
    /**- Program Derived Address derived by `"invite"` and the public key of the invite
    - Do note that, the invitePDA requires to be generated client side, [refer to docs](/docs/send)
    - Please handle invite code and secret key with highest security as user funds are involved
    */
    #[serde(rename = "invitePDA")]
    pub invite_pda: String,
    /**- Public key address of the sender
    - Since this address funded the invite, it will be the receiving address of the full amount
    */
    pub sender: String,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PostSendV1CraftClawbackResponse {
    /**- Base64-encoded unsigned Send transaction
     */
    pub tx: String,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PostSendV1CraftClawbackResponse400 {
    pub error: String,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PostSendV1CraftClawbackResponse500 {
    pub error: String,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PostSendV1CraftSendRequest {
    /**- Amount in atomic value (before decimals)
    - E.g. to send 1 USDC is equivalent of `amount='1000000'`
    - Do note that there will be additional SOL amount being used in the transaction for transaction fees and token accounts
    */
    pub amount: String,
    /**- Public key address generated from the hash of the invite code
    - Do note that, the invite code requires to be generated client side, [refer to docs](/docs/send)
    - Please handle invite code and secret key with highest security as user funds are involved
    */
    #[serde(rename = "inviteSigner")]
    pub invite_signer: String,
    /**- Defaults to WSOL mint
    - Only pass in this parameter with other mint when required
    */
    #[serde(skip_serializing_if = "Option::is_none")]
    pub mint: Option<String>,
    /**- Public key address of the sender
    - This address will be funding the amount to be sent and the token accounts involved
    */
    pub sender: String,
}
impl PostSendV1CraftSendRequest {
    /// Construct this request with every required wire field.
    pub fn new(amount: String, invite_signer: String, sender: String) -> Self {
        Self {
            amount,
            invite_signer,
            sender,
            mint: None,
        }
    }
    /// Start a dependency-free builder with every required wire field.
    pub fn builder(
        amount: String,
        invite_signer: String,
        sender: String,
    ) -> PostSendV1CraftSendRequestBuilder {
        PostSendV1CraftSendRequestBuilder::new(amount, invite_signer, sender)
    }
}
/// Dependency-free builder for [`#struct_name`].
#[derive(Debug, Clone)]
#[must_use]
pub struct PostSendV1CraftSendRequestBuilder {
    value: PostSendV1CraftSendRequest,
}
impl PostSendV1CraftSendRequestBuilder {
    /// Start a builder with every required wire field.
    pub fn new(amount: String, invite_signer: String, sender: String) -> Self {
        Self {
            value: PostSendV1CraftSendRequest::new(amount, invite_signer, sender),
        }
    }
    #[doc = concat!("Set the optional `", "mint", "` request field.")]
    #[must_use]
    pub fn mint(mut self, mint: String) -> Self {
        self.value.mint = Some(mint);
        self
    }
    /// Finish building the request model.
    pub fn build(self) -> PostSendV1CraftSendRequest {
        self.value
    }
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PostSendV1CraftSendResponse {
    /**- Unix timestamp of when the invite will expire
    - Expired invites will automatically clawback to sender
    */
    pub expiry: String,
    /**- Amount of fees required for network's transaction fee and token accounts
     */
    #[serde(rename = "totalFeeLamports")]
    pub total_fee_lamports: String,
    /**- Base64-encoded unsigned Send transaction
     */
    pub tx: String,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PostSendV1CraftSendResponse400 {
    pub error: String,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PostSendV1CraftSendResponse500 {
    pub error: String,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PostStudioV1DbcFeeCreateTxResponse {
    ///Base64-encoded transaction ready for signing
    pub transaction: String,
}
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct PostStudioV1DbcFeeCreateTxResponse403 {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub error: Option<String>,
}
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct PostStudioV1DbcFeeCreateTxResponse404 {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub error: Option<String>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PostStudioV1DbcFeeRequest {
    /**- Dynamic Bonding Curve pool address
     */
    #[serde(rename = "poolAddress")]
    pub pool_address: String,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PostStudioV1DbcFeeResponse {
    /**- Total trading quote fee amount divided by 2 (creator share)
     */
    pub total: String,
    /**- Unclaimed creator quote fee amount
     */
    pub unclaimed: String,
}
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct PostStudioV1DbcPoolCreateTxResponse400 {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub error: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub errors: Option<serde_json::Value>,
}
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct PostStudioV1DbcPoolCreateTxResponse500 {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub details: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub error: Option<String>,
}
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct PostStudioV1DbcPoolSubmitResponse400 {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub error: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub errors: Option<serde_json::Value>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PostTriggerV1CancelOrderRequest {
    /**In microlamports, defaults to 95th percentile of priority fees
     */
    #[serde(rename = "computeUnitPrice", skip_serializing_if = "Option::is_none")]
    pub compute_unit_price: Option<String>,
    #[serde(default)]
    pub maker: String,
    #[serde(default)]
    pub order: String,
}
impl PostTriggerV1CancelOrderRequest {
    /// Construct this request with every required wire field.
    pub fn new(maker: String, order: String) -> Self {
        Self {
            maker,
            order,
            compute_unit_price: None,
        }
    }
    /// Start a dependency-free builder with every required wire field.
    pub fn builder(maker: String, order: String) -> PostTriggerV1CancelOrderRequestBuilder {
        PostTriggerV1CancelOrderRequestBuilder::new(maker, order)
    }
}
/// Dependency-free builder for [`#struct_name`].
#[derive(Debug, Clone)]
#[must_use]
pub struct PostTriggerV1CancelOrderRequestBuilder {
    value: PostTriggerV1CancelOrderRequest,
}
impl PostTriggerV1CancelOrderRequestBuilder {
    /// Start a builder with every required wire field.
    pub fn new(maker: String, order: String) -> Self {
        Self {
            value: PostTriggerV1CancelOrderRequest::new(maker, order),
        }
    }
    #[doc = concat!("Set the optional `", "computeUnitPrice", "` request field.")]
    #[must_use]
    pub fn compute_unit_price(mut self, compute_unit_price: String) -> Self {
        self.value.compute_unit_price = Some(compute_unit_price);
        self
    }
    /// Finish building the request model.
    pub fn build(self) -> PostTriggerV1CancelOrderRequest {
        self.value
    }
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PostTriggerV1CancelOrderResponse {
    ///Required to make a request to `/execute`
    #[serde(rename = "requestId")]
    pub request_id: String,
    ///Unsigned base-64 encoded transaction
    pub transaction: String,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PostTriggerV1CancelOrdersRequest {
    /**In microlamports, defaults to 95th percentile of priority fees
     */
    #[serde(rename = "computeUnitPrice", skip_serializing_if = "Option::is_none")]
    pub compute_unit_price: Option<String>,
    #[serde(default)]
    pub maker: String,
    /**Array of orders to cancel, if none is provided, the API will generate cancel instructions for all open orders belonging to the maker
     */
    #[serde(skip_serializing_if = "Option::is_none")]
    pub orders: Option<Vec<String>>,
}
impl PostTriggerV1CancelOrdersRequest {
    /// Construct this request with every required wire field.
    pub fn new(maker: String) -> Self {
        Self {
            maker,
            compute_unit_price: None,
            orders: None,
        }
    }
    /// Start a dependency-free builder with every required wire field.
    pub fn builder(maker: String) -> PostTriggerV1CancelOrdersRequestBuilder {
        PostTriggerV1CancelOrdersRequestBuilder::new(maker)
    }
}
/// Dependency-free builder for [`#struct_name`].
#[derive(Debug, Clone)]
#[must_use]
pub struct PostTriggerV1CancelOrdersRequestBuilder {
    value: PostTriggerV1CancelOrdersRequest,
}
impl PostTriggerV1CancelOrdersRequestBuilder {
    /// Start a builder with every required wire field.
    pub fn new(maker: String) -> Self {
        Self {
            value: PostTriggerV1CancelOrdersRequest::new(maker),
        }
    }
    #[doc = concat!("Set the optional `", "computeUnitPrice", "` request field.")]
    #[must_use]
    pub fn compute_unit_price(mut self, compute_unit_price: String) -> Self {
        self.value.compute_unit_price = Some(compute_unit_price);
        self
    }
    #[doc = concat!("Set the optional `", "orders", "` request field.")]
    #[must_use]
    pub fn orders(mut self, orders: Vec<String>) -> Self {
        self.value.orders = Some(orders);
        self
    }
    /// Finish building the request model.
    pub fn build(self) -> PostTriggerV1CancelOrdersRequest {
        self.value
    }
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PostTriggerV1CancelOrdersResponse {
    ///Required to make a request to `/execute`
    #[serde(rename = "requestId")]
    pub request_id: String,
    ///Array of unsigned base-64 encoded transaction(s)
    pub transactions: Vec<String>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PostTriggerV1CreateOrderResponse {
    ///Base-58 account which is the Trigger Order account
    #[serde(skip_serializing_if = "Option::is_none")]
    pub order: Option<String>,
    ///Required to make a request to `/execute`
    #[serde(rename = "requestId")]
    pub request_id: String,
    ///Unsigned base-64 encoded transaction
    pub transaction: String,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PostTriggerV1ExecuteRequest {
    ///Found in the response of `/createOrder` or `/cancelOrder`
    #[serde(rename = "requestId")]
    pub request_id: String,
    ///The signed transaction to execute
    #[serde(rename = "signedTransaction")]
    pub signed_transaction: String,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PostTriggerV2AuthVerifyResponse {
    ///JWT token (24h TTL)
    pub token: String,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PostTriggerV2DepositCraftResponse {
    ///Deposit amount in smallest unit
    pub amount: String,
    ///Deterministic per-order input token account. Returned for deposits crafted with an orderSubType.
    #[serde(rename = "inputTokenAccount", skip_serializing_if = "Option::is_none")]
    pub input_token_account: Option<String>,
    ///Jupiter Lend position account. Returned instead of inputTokenAccount when the deposit is crafted with jlMint (Earn While You Wait).
    #[serde(rename = "jlTokenAccount", skip_serializing_if = "Option::is_none")]
    pub jl_token_account: Option<String>,
    ///Token mint being deposited
    pub mint: String,
    ///Deterministic per-order output token account. Returned only when orderSubType is otoco.
    #[serde(rename = "outputTokenAccount", skip_serializing_if = "Option::is_none")]
    pub output_token_account: Option<String>,
    ///Vault public key receiving the deposit
    #[serde(rename = "receiverAddress")]
    pub receiver_address: String,
    ///Deposit request ID (used when creating the order)
    #[serde(rename = "requestId")]
    pub request_id: String,
    ///Token decimals
    #[serde(rename = "tokenDecimals")]
    pub token_decimals: f64,
    ///Base64-encoded unsigned transaction
    pub transaction: String,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PostTriggerV2OrdersDcaCancelIdResponse {
    pub id: String,
    ///Amount to be refunded in smallest units
    #[serde(rename = "refundAmount")]
    pub refund_amount: String,
    ///Pass to confirm-cancel as cancelRequestId
    #[serde(rename = "requestId")]
    pub request_id: String,
    ///Rounds that will not execute
    #[serde(rename = "roundsRemaining")]
    pub rounds_remaining: f64,
    ///Base64-encoded unsigned withdrawal transaction
    pub transaction: String,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PostTriggerV2OrdersDcaConfirmCancelIdRequest {
    ///requestId from the cancel response
    #[serde(rename = "cancelRequestId")]
    pub cancel_request_id: String,
    ///Base64-encoded signed withdrawal transaction
    #[serde(rename = "signedTransaction")]
    pub signed_transaction: String,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PostTriggerV2OrdersPriceCancelOrderIdResponse {
    pub id: String,
    ///Cancel request ID (used in confirm step)
    #[serde(rename = "requestId")]
    pub request_id: String,
    ///Base64-encoded unsigned withdrawal transaction
    pub transaction: String,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PostTriggerV2OrdersPriceConfirmCancelOrderIdRequest {
    ///Cancel request ID from the initiate step
    #[serde(rename = "cancelRequestId")]
    pub cancel_request_id: String,
    ///Base64-encoded signed withdrawal transaction
    #[serde(rename = "signedTransaction")]
    pub signed_transaction: String,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PostUltraV1ExecuteRequest {
    /**- Found in response of `/order`
     */
    #[serde(rename = "requestId")]
    pub request_id: String,
    /**- The signed transaction to execute
     */
    #[serde(rename = "signedTransaction")]
    pub signed_transaction: String,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PostUltraV1ExecuteResponse400 {
    pub code: f64,
    pub error: String,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PostUltraV1ExecuteResponse500 {
    pub code: f64,
    pub error: String,
}
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct PredictionClaimPositionRequest {
    ///Position owner public key
    ///Constraint: minLength=32
    #[serde(rename = "ownerPubkey", skip_serializing_if = "Option::is_none")]
    pub owner_pubkey: Option<String>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PredictionCloseAllPositionsRequest {
    ///Slippage tolerance applied to each sell, in basis points. Required.
    #[serde(rename = "minSellPriceSlippageBps")]
    pub min_sell_price_slippage_bps: f64,
    ///Position owner public key
    ///Constraint: minLength=32
    #[serde(rename = "ownerPubkey", skip_serializing_if = "Option::is_none")]
    pub owner_pubkey: Option<String>,
}
impl PredictionCloseAllPositionsRequest {
    /// Construct this request with every required wire field.
    pub fn new(min_sell_price_slippage_bps: f64) -> Self {
        Self {
            min_sell_price_slippage_bps,
            owner_pubkey: None,
        }
    }
    /// Start a dependency-free builder with every required wire field.
    pub fn builder(min_sell_price_slippage_bps: f64) -> PredictionCloseAllPositionsRequestBuilder {
        PredictionCloseAllPositionsRequestBuilder::new(min_sell_price_slippage_bps)
    }
}
/// Dependency-free builder for [`#struct_name`].
#[derive(Debug, Clone)]
#[must_use]
pub struct PredictionCloseAllPositionsRequestBuilder {
    value: PredictionCloseAllPositionsRequest,
}
impl PredictionCloseAllPositionsRequestBuilder {
    /// Start a builder with every required wire field.
    pub fn new(min_sell_price_slippage_bps: f64) -> Self {
        Self {
            value: PredictionCloseAllPositionsRequest::new(min_sell_price_slippage_bps),
        }
    }
    #[doc = concat!("Set the optional `", "ownerPubkey", "` request field.")]
    #[must_use]
    pub fn owner_pubkey(mut self, owner_pubkey: String) -> Self {
        self.value.owner_pubkey = Some(owner_pubkey);
        self
    }
    /// Finish building the request model.
    pub fn build(self) -> PredictionCloseAllPositionsRequest {
        self.value
    }
}
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct PredictionClosePositionRequest {
    ///Position owner public key
    ///Constraint: minLength=32
    #[serde(rename = "ownerPubkey", skip_serializing_if = "Option::is_none")]
    pub owner_pubkey: Option<String>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct PredictionTradingStatusResponse {
    pub trading_active: bool,
}
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct ProgramIdToLabelGetResponse {
    /// Additional properties matching the spec's
    /// `additionalProperties` value schema.
    #[serde(flatten)]
    pub additional_properties: std::collections::BTreeMap<String, String>,
}
///DEPRECATED: Price-based recurring orders are deprecated
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct RecurringDepositPriceRecurring {
    ///Constraint: minimum=0
    pub amount: i64,
    ///Base-58 account which is the Recurring Order account
    pub order: String,
    pub user: String,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct RecurringExecuteRecurring {
    #[serde(rename = "requestId")]
    pub request_id: String,
    #[serde(rename = "signedTransaction")]
    pub signed_transaction: String,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct RecurringRecurringResponse {
    ///Required to make a request to `/execute`
    #[serde(rename = "requestId")]
    pub request_id: String,
    ///Unsigned base-64 encoded transaction
    pub transaction: String,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct StudioCreateClaimFeeDBCTransactionRequestBody {
    /**- Maximum quote amount to claim
     */
    ///Constraint: minimum=0
    #[serde(rename = "maxQuoteAmount")]
    pub max_quote_amount: f64,
    /**- Owner wallet public key
     */
    #[serde(rename = "ownerWallet")]
    pub owner_wallet: String,
    /**- Dynamic Bonding Curve pool address
     */
    #[serde(rename = "poolAddress")]
    pub pool_address: String,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct StudioCreateDBCTransactionResponse {
    /**- Presigned URL for image upload via `PUT` request
    - This is for you to make a PUT request to upload your token image to the on-chain uri metadata
    - [Refer to the Token Metadata section for better understanding](/docs/studio/create-token#token-metadata)
    */
    #[serde(rename = "imagePresignedUrl")]
    pub image_presigned_url: url::Url,
    ///Final image URL
    #[serde(rename = "imageUrl")]
    pub image_url: url::Url,
    /**- Presigned URL for metadata upload via `PUT` request
    - This is for you to make a PUT request to upload your token metadata to the on-chain uri metadata
    - [Refer to the Token Metadata section for better understanding](/docs/studio/create-token#token-metadata)
    */
    #[serde(rename = "metadataPresignedUrl")]
    pub metadata_presigned_url: url::Url,
    ///Generated token mint address
    pub mint: String,
    ///Base64-encoded transaction ready for signing
    pub transaction: String,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct StudioSubmitDBCTransactionRequestBody {
    /**- Optional content description displayed on Studio dedicated token page
    - This is stored off-chain for our frontend to display
    - This is NOT the on-chain token metadata
    - The on-chain token metadata is done by making a PUT request to the presigned URL
    */
    #[serde(skip_serializing_if = "Option::is_none")]
    pub content: Option<String>,
    /**- Optional header image file displayed on Studio token page
    - This is stored off-chain for our frontend to display
    - This is NOT the on-chain token metadata
    - The on-chain token metadata is done by making a PUT request to the presigned URL
    */
    #[serde(rename = "headerImage", skip_serializing_if = "Option::is_none")]
    pub header_image: Option<bytes::Bytes>,
    /**- Owner wallet public key
     */
    pub owner: String,
    /**- Base64-encoded signed transaction
     */
    pub transaction: String,
}
impl StudioSubmitDBCTransactionRequestBody {
    /// Construct this request with every required wire field.
    pub fn new(owner: String, transaction: String) -> Self {
        Self {
            owner,
            transaction,
            content: None,
            header_image: None,
        }
    }
    /// Start a dependency-free builder with every required wire field.
    pub fn builder(
        owner: String,
        transaction: String,
    ) -> StudioSubmitDBCTransactionRequestBodyBuilder {
        StudioSubmitDBCTransactionRequestBodyBuilder::new(owner, transaction)
    }
}
/// Dependency-free builder for [`#struct_name`].
#[derive(Debug, Clone)]
#[must_use]
pub struct StudioSubmitDBCTransactionRequestBodyBuilder {
    value: StudioSubmitDBCTransactionRequestBody,
}
impl StudioSubmitDBCTransactionRequestBodyBuilder {
    /// Start a builder with every required wire field.
    pub fn new(owner: String, transaction: String) -> Self {
        Self {
            value: StudioSubmitDBCTransactionRequestBody::new(owner, transaction),
        }
    }
    #[doc = concat!("Set the optional `", "content", "` request field.")]
    #[must_use]
    pub fn content(mut self, content: String) -> Self {
        self.value.content = Some(content);
        self
    }
    #[doc = concat!("Set the optional `", "headerImage", "` request field.")]
    #[must_use]
    pub fn header_image(mut self, header_image: bytes::Bytes) -> Self {
        self.value.header_image = Some(header_image);
        self
    }
    /// Finish building the request model.
    pub fn build(self) -> StudioSubmitDBCTransactionRequestBody {
        self.value
    }
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct SwapV1SwapResponse {
    #[serde(rename = "lastValidBlockHeight")]
    pub last_valid_block_height: u64,
    #[serde(
        rename = "prioritizationFeeLamports",
        skip_serializing_if = "Option::is_none"
    )]
    pub prioritization_fee_lamports: Option<u64>,
    #[serde(rename = "swapTransaction")]
    pub swap_transaction: String,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct TokensV1MintIncludingDuplicates {
    pub address: String,
    pub created_at: chrono::DateTime<chrono::Utc>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub daily_volume: Option<i64>,
    pub decimals: i32,
    pub extensions: serde_json::Value,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub freeze_authority: Option<String>,
    #[serde(rename = "logoURI", skip_serializing_if = "Option::is_none")]
    pub logo_uri: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub mint_authority: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub minted_at: Option<chrono::DateTime<chrono::Utc>>,
    pub name: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub permanent_delegate: Option<String>,
    pub symbol: String,
    pub tags: Vec<String>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct TokensV2VerificationCheckEligibilityResponse {
    ///Whether a metadata update can be submitted
    #[serde(rename = "canMetadata")]
    pub can_metadata: bool,
    ///Whether a verification request can be submitted
    #[serde(rename = "canVerify")]
    pub can_verify: bool,
    ///Whether the token is already verified
    #[serde(rename = "isVerified")]
    pub is_verified: bool,
    ///Reason metadata update is not allowed (only present when there is a specific error)
    #[serde(rename = "metadataError", skip_serializing_if = "Option::is_none")]
    pub metadata_error: Option<String>,
    ///Whether the token exists on-chain
    #[serde(rename = "tokenExists")]
    pub token_exists: bool,
    ///Reason verification is not allowed (only present when there is a specific error)
    #[serde(rename = "verificationError", skip_serializing_if = "Option::is_none")]
    pub verification_error: Option<String>,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct TokensV2VerificationCraftTxnResponse {
    ///JUP amount collected in smallest unit. JUP path transfers exactly 1000 JUP (1000000000); swap paths yield at least that.
    pub amount: String,
    ///Status code (0 for success)
    pub code: f64,
    ///Error message if crafting failed
    #[serde(skip_serializing_if = "Option::is_none")]
    pub error: Option<String>,
    ///Expiry timestamp for the crafted transaction
    #[serde(rename = "expireAt", skip_serializing_if = "Option::is_none")]
    pub expire_at: Option<String>,
    ///Fee amount in smallest unit
    #[serde(rename = "feeAmount")]
    pub fee_amount: f64,
    ///Transaction fee in lamports
    #[serde(rename = "feeLamports")]
    pub fee_lamports: f64,
    ///Mint address of the fee token
    #[serde(rename = "feeMint")]
    pub fee_mint: String,
    ///Decimals of the fee token
    #[serde(rename = "feeTokenDecimals")]
    pub fee_token_decimals: f64,
    ///Transaction fee in USD
    #[serde(rename = "feeUsdAmount", skip_serializing_if = "Option::is_none")]
    pub fee_usd_amount: Option<f64>,
    ///Whether the transaction is gasless
    pub gasless: bool,
    ///Input token decimals (non-JUP paths)
    #[serde(rename = "inputDecimals", skip_serializing_if = "Option::is_none")]
    pub input_decimals: Option<f64>,
    ///Input token mint address (non-JUP paths)
    #[serde(rename = "inputMint", skip_serializing_if = "Option::is_none")]
    pub input_mint: Option<String>,
    ///Maximum atomic input amount for the swap; equal to quotedInputAmount on the current swap flow (non-JUP paths)
    #[serde(rename = "maxInputAmount", skip_serializing_if = "Option::is_none")]
    pub max_input_amount: Option<String>,
    ///Mint address of the payment token (JUP)
    pub mint: String,
    ///Atomic input amount for the swap, sized to yield at least 1000 JUP (non-JUP paths)
    #[serde(rename = "quotedInputAmount", skip_serializing_if = "Option::is_none")]
    pub quoted_input_amount: Option<String>,
    ///Wallet address receiving the JUP payment
    #[serde(rename = "receiverAddress")]
    pub receiver_address: String,
    ///Unique request ID. Pass this to the execute endpoint.
    #[serde(rename = "requestId")]
    pub request_id: String,
    ///Decimals of the payment token
    #[serde(rename = "tokenDecimals")]
    pub token_decimals: f64,
    ///USD rate of the payment token at time of crafting
    #[serde(rename = "tokenUsdRate", skip_serializing_if = "Option::is_none")]
    pub token_usd_rate: Option<f64>,
    ///Time taken to craft the transaction in milliseconds
    #[serde(rename = "totalTime")]
    pub total_time: f64,
    ///Base64-encoded unsigned transaction
    pub transaction: String,
}
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
pub struct TokensV2VerificationErrorResponse {
    #[serde(skip_serializing_if = "Option::is_none")]
    pub error: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub message: Option<String>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub status: Option<f64>,
}
///Response for a price order create. The deposit lands synchronously during the call, so depositConfirmed is returned. DCA create and confirm-cancel use TxSignatureResponse instead.
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct TriggerV2OrderResponse {
    ///Whether the deposit has landed and the order is active
    #[serde(rename = "depositConfirmed")]
    pub deposit_confirmed: bool,
    ///Order UUID
    pub id: String,
    ///Additional context about the deposit state, present on idempotent retries
    #[serde(skip_serializing_if = "Option::is_none")]
    pub message: Option<String>,
    ///On-chain signature of the deposit transaction
    #[serde(rename = "txSignature")]
    pub tx_signature: String,
}
///Minimal create/cancel response carrying the order ID and an on-chain transaction signature. Returned by DCA create (deposit signature) and by confirm-cancel (withdrawal signature). Unlike price order create, it does not include depositConfirmed.
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct TriggerV2TxSignatureResponse {
    ///Order UUID
    pub id: String,
    ///On-chain transaction signature
    #[serde(rename = "txSignature")]
    pub tx_signature: String,
}
#[derive(Debug, Clone, Deserialize, Serialize)]
pub struct UltraNativeHoldingsResponse {
    ///Total SOL in lamports
    pub amount: String,
    ///Total SOL in UI units after applying decimals
    #[serde(rename = "uiAmount")]
    pub ui_amount: f64,
    ///Total SOL as string in UI units after applying decimals
    #[serde(rename = "uiAmountString")]
    pub ui_amount_string: String,
}