import {z} from 'zod'

export type CoreSortOrder = 'ASC' | 'DESC';

export type CoreTransactionOrderParameterType = 'Algorand' | 'Bitcoin' | 'BitcoinRedirect' | 'Cardano' | 'Ethereum' | 'Hedera' | 'Solana' | 'Substrate' | 'Tezos' | 'XRPL' | 'Stellar' | 'Tron';

export type GetApiV1DomainsDomainIdTransactionsOrdersArgs = {domainId: string, limit?: number | undefined, startingAfter?: string | undefined, sortBy?: ('id' | 'accountId' | 'metadata.createdAt' | 'metadata.lastModifiedAt') | undefined, sortOrder?: CoreSortOrder | undefined, accountId?: Array<string> | undefined, ledgerId?: Array<string> | undefined, intentId?: string | undefined, 'parameters.type'?: CoreTransactionOrderParameterType | undefined, 'metadata.createdBy'?: string | undefined, 'metadata.lastModifiedBy'?: string | undefined, 'metadata.createdAt.lt'?: string | undefined, 'metadata.createdAt.gt'?: string | undefined, 'metadata.lastModifiedAt.lt'?: string | undefined, 'metadata.lastModifiedAt.gt'?: string | undefined, 'metadata.description'?: string | undefined, 'metadata.customProperties'?: Array<string> | undefined};

export type GetApiV1DomainsDomainIdTransactionsOrdersOptions = {baseUrl: string, httpAuth?: string | undefined, fetch?: typeof fetch | undefined};

export const coreTransactionDestinationAccount = z.object({accountId: z.string(), type: z.literal("Account")});

export const coreTransactionDestinationAddress = z.object({address: z.string().min(1).max(512), type: z.literal("Address")});

export const coreTransactionDestinationEndpoint = z.object({endpointId: z.string(), type: z.literal("Endpoint")});

export const coreTransactionDestination = z.discriminatedUnion("type", [coreTransactionDestinationAccount, coreTransactionDestinationAddress, coreTransactionDestinationEndpoint]);

export const coreAlgorandOperation = z.object({destination: coreTransactionDestination, amount: z.string(), type: z.literal("Payment")});

export const coreFeePriority = z.enum(["High", "Medium", "Low"]);

export const coreAlgorandFeeStrategy = z.object({priority: coreFeePriority, type: z.literal("Priority")});

export const coreTransactionOrderParametersAlgorand = z.object({operation: coreAlgorandOperation, note: z.string().max(1024).optional(), feeStrategy: coreAlgorandFeeStrategy, maximumFee: z.string().optional(), type: z.literal("Algorand")});

export const coreBitcoinOutputParameters = z.object({destination: coreTransactionDestination, amount: z.string(), paysFee: z.boolean().optional()});

export const coreBitcoinFeeStrategyPriority = z.object({priority: coreFeePriority, type: z.literal("Priority")});

export const coreBitcoinFeeStrategySpecifiedRate = z.object({satoshiPerVbyte: z.string(), type: z.literal("SpecifiedRate")});

export const coreBitcoinFeeStrategy = z.discriminatedUnion("type", [coreBitcoinFeeStrategyPriority, coreBitcoinFeeStrategySpecifiedRate]);

export const coreBitcoinResourceStrategy = z.object({transactionOrderId: z.string(), reason: z.string().min(1).max(200).optional(), type: z.literal("OrderReplacement")});

export const coreAddressForChange = z.enum(["GenerateNewAddress", "PrimaryAddress"]);

export const coreTransactionOrderParametersBitcoin = z.object({outputs: z.array(coreBitcoinOutputParameters), feeStrategy: coreBitcoinFeeStrategy, maximumFee: z.string().optional(), resourceStrategy: coreBitcoinResourceStrategy.optional(), addressForChange: coreAddressForChange.optional(), type: z.literal("Bitcoin")});

export const coreTransactionOrderParametersBitcoinRedirect = z.object({transferIds: z.array(z.string()), outputs: z.array(coreBitcoinOutputParameters), feeStrategy: coreBitcoinFeeStrategy, maximumFee: z.string().optional(), type: z.literal("BitcoinRedirect")});

export const coreDelegateRepresentativeParameters = z.object({type: z.literal("AlwaysAbstain")});

export const coreCardanoOperationDelegateRepresentative = z.object({parameters: coreDelegateRepresentativeParameters, type: z.literal("DelegateRepresentative")});

export const coreCardanoOperationDelegateStaking = z.object({poolId: z.string().min(56).max(56), type: z.literal("DelegateStaking")});

export const coreCardanoOperationRegisterStaking = z.object({type: z.literal("RegisterStaking")});

export const coreCardanoOutputParameters = z.object({destination: coreTransactionDestination, amount: z.string(), paysFee: z.boolean().optional()});

export const coreCardanoOperationTransfer = z.object({outputs: z.array(coreCardanoOutputParameters), type: z.literal("Transfer")});

export const coreCardanoOperationUnregisterStaking = z.object({type: z.literal("UnregisterStaking")});

export const coreCardanoOperationWithdrawRewards = z.object({amount: z.string(), type: z.literal("WithdrawRewards")});

export const coreCardanoOperation = z.discriminatedUnion("type", [coreCardanoOperationDelegateRepresentative, coreCardanoOperationDelegateStaking, coreCardanoOperationRegisterStaking, coreCardanoOperationTransfer, coreCardanoOperationUnregisterStaking, coreCardanoOperationWithdrawRewards]);

export const coreCardanoFeeStrategy = z.object({priority: coreFeePriority, type: z.literal("Priority")});

export const coreTransactionOrderParametersCardano = z.object({operation: coreCardanoOperation, feeStrategy: coreCardanoFeeStrategy, maximumFee: z.string().optional(), type: z.literal("Cardano")});

export const coreEthereumFeeStrategyPriority = z.object({priority: coreFeePriority, type: z.literal("Priority")});

export const coreEthereumFeeStrategySpecifiedRate = z.object({gasPrice: z.string(), type: z.literal("SpecifiedRate")});

export const coreEthereumFeeStrategySpecifiedRateEIP1559 = z.object({maxFeePerGas: z.string(), maxPriorityFeePerGas: z.string(), type: z.literal("SpecifiedRateEIP1559")});

export const coreEthereumFeeStrategy = z.discriminatedUnion("type", [coreEthereumFeeStrategyPriority, coreEthereumFeeStrategySpecifiedRate, coreEthereumFeeStrategySpecifiedRateEIP1559]);

export const coreEthereumResourceStrategy = z.object({transactionOrderId: z.string(), reason: z.string().min(1).max(200).optional(), type: z.literal("OrderReplacement")});

export const coreTransactionOrderParametersEthereum = z.object({destination: coreTransactionDestination.optional(), amount: z.string(), feeStrategy: coreEthereumFeeStrategy, maximumFee: z.string().optional(), data: z.string().optional(), resourceStrategy: coreEthereumResourceStrategy.optional(), type: z.literal("Ethereum")});

export const coreHederaOperationAccountUpdate = z.object({maxAutomaticTokenAssociations: z.number().int(), type: z.literal("AccountUpdate")});

export const coreTokenDestinationTicker = z.object({tickerId: z.string(), type: z.literal("Ticker")});

export const coreTokenDestinationTokenId = z.object({tokenId: z.string().min(5).max(20), type: z.literal("TokenId")});

export const coreTokenDestination = z.discriminatedUnion("type", [coreTokenDestinationTicker, coreTokenDestinationTokenId]);

export const coreHederaOperationTokenAssociate = z.object({tokens: z.array(coreTokenDestination), type: z.literal("TokenAssociate")});

export const coreHederaOperationTokenDissociate = z.object({tokens: z.array(coreTokenDestination), type: z.literal("TokenDissociate")});

export const coreHederaTransferOutput = z.object({destination: coreTransactionDestination, amount: z.string()});

export const coreTokenOutputHederaFungibleTokenOutput = z.object({token: coreTokenDestination, destination: coreTransactionDestination, amount: z.string(), type: z.literal("HederaFungibleTokenOutput")});

export const coreNonFungibleTokenDestinationNftTokenId = z.object({tokenId: z.string().min(5).max(20), serialNumber: z.number().int(), type: z.literal("NftTokenId")});

export const coreNonFungibleTokenDestinationTicker = z.object({tickerId: z.string(), type: z.literal("Ticker")});

export const coreNonFungibleTokenDestination = z.discriminatedUnion("type", [coreNonFungibleTokenDestinationNftTokenId, coreNonFungibleTokenDestinationTicker]);

export const coreTokenOutputHederaNonFungibleTokenOutput = z.object({token: coreNonFungibleTokenDestination, destination: coreTransactionDestination, type: z.literal("HederaNonFungibleTokenOutput")});

export const coreTokenOutput = z.discriminatedUnion("type", [coreTokenOutputHederaFungibleTokenOutput, coreTokenOutputHederaNonFungibleTokenOutput]);

export const coreHederaOperationTransfer = z.object({outputs: z.array(coreHederaTransferOutput).optional(), tokenOutputs: z.array(coreTokenOutput).optional(), type: z.literal("Transfer")});

export const coreHederaOperation = z.discriminatedUnion("type", [coreHederaOperationAccountUpdate, coreHederaOperationTokenAssociate, coreHederaOperationTokenDissociate, coreHederaOperationTransfer]);

export const coreHederaFeeStrategy = z.object({priority: coreFeePriority, type: z.literal("Priority")});

export const coreTransactionOrderParametersHedera = z.object({operation: coreHederaOperation, memo: z.string().min(1).max(100).optional(), feeStrategy: coreHederaFeeStrategy, maximumFee: z.string().optional(), type: z.literal("Hedera")});

export const coreSolanaMintAccountDestination = z.object({destination: coreTransactionDestination, type: z.literal("Destination")});

export const coreSolanaMintAccountTicker = z.object({tickerId: z.string(), type: z.literal("Ticker")});

export const coreSolanaMintAccount = z.discriminatedUnion("type", [coreSolanaMintAccountDestination, coreSolanaMintAccountTicker]);

export const coreSolanaOperationBurn = z.object({mintAccount: coreSolanaMintAccount, amount: z.string(), type: z.literal("Burn")});

export const coreSolanaOperationCreateNonceAccount = z.object({createOnAccount: z.string(), type: z.literal("CreateNonceAccount")});

export const coreSolanaOperationFundAtaAccount = z.object({destination: coreTransactionDestination.optional(), mintAccount: coreSolanaMintAccount, type: z.literal("FundAtaAccount")});

export const coreSolanaTokenType = z.enum(["SPL", "SPL2022"]);

export const coreSolanaOperationInitializeMint = z.object({mintAccount: z.string(), decimals: z.number().int().gte(0), tokenType: coreSolanaTokenType, type: z.literal("InitializeMint")});

export const coreSolanaOperationMintTo = z.object({destination: coreTransactionDestination, mintAccount: coreSolanaMintAccount, amount: z.string(), type: z.literal("MintTo")});

export const coreSolanaTransferOutput = z.object({destination: coreTransactionDestination, amount: z.string()});

export const coreSolanaOperationTransfer = z.object({outputs: z.array(coreSolanaTransferOutput), type: z.literal("Transfer")});

export const coreSolanaOperationTransferToken = z.object({outputs: z.array(coreSolanaTransferOutput), mintAccount: coreSolanaMintAccount, type: z.literal("TransferToken")});

export const coreSolanaOperation = z.discriminatedUnion("type", [coreSolanaOperationBurn, coreSolanaOperationCreateNonceAccount, coreSolanaOperationFundAtaAccount, coreSolanaOperationInitializeMint, coreSolanaOperationMintTo, coreSolanaOperationTransfer, coreSolanaOperationTransferToken]);

export const coreSolanaFeeStrategy = z.object({priority: coreFeePriority, type: z.literal("Priority")});

export const coreTransactionOrderParametersSolana = z.object({operation: coreSolanaOperation, memos: z.array(z.string().max(566)), feeStrategy: coreSolanaFeeStrategy, maximumFee: z.string().optional(), nonceAccount: coreTransactionDestination.optional(), type: z.literal("Solana")});

export const coreStellarOperationAccountMerge = z.object({destination: coreTransactionDestination, type: z.literal("AccountMerge")});

export const coreStellarAsset = z.object({code: z.string().min(1).max(100), issuer: z.string().min(1).max(512)});

export const coreStellarOperationChangeTrust = z.object({limit: z.string(), asset: coreStellarAsset, type: z.literal("ChangeTrust")});

export const coreStellarOperationCreateAccount = z.object({destination: coreTransactionDestination, startingBalance: z.string(), type: z.literal("CreateAccount")});

export const coreStellarOperationPayment = z.object({destination: coreTransactionDestination, amount: z.string(), asset: coreStellarAsset.optional(), type: z.literal("Payment")});

export const coreStellarOptionOptionHomeDomain = z.object({homeDomain: z.string(), type: z.literal("OptionHomeDomain")});

export const coreStellarOptionFlag = z.literal("AuthImmutable");

export const coreStellarOptionOptionSetFlag = z.object({setFlag: coreStellarOptionFlag, type: z.literal("OptionSetFlag")});

export const coreStellarOption = z.discriminatedUnion("type", [coreStellarOptionOptionHomeDomain, coreStellarOptionOptionSetFlag]);

export const coreStellarOperationSetOptions = z.object({option: coreStellarOption, type: z.literal("SetOptions")});

export const coreStellarOperation = z.discriminatedUnion("type", [coreStellarOperationAccountMerge, coreStellarOperationChangeTrust, coreStellarOperationCreateAccount, coreStellarOperationPayment, coreStellarOperationSetOptions]);

export const coreStellarMemoHash = z.object({value: z.string().min(64).max(64), type: z.literal("Hash")});

export const coreStellarMemoId = z.object({value: z.string(), type: z.literal("Id")});

export const coreStellarMemoReturn = z.object({value: z.string().min(64).max(64), type: z.literal("Return")});

export const coreStellarMemoText = z.object({value: z.string().min(1).max(28), type: z.literal("Text")});

export const coreStellarMemo = z.discriminatedUnion("type", [coreStellarMemoHash, coreStellarMemoId, coreStellarMemoReturn, coreStellarMemoText]);

export const coreStellarFeeStrategyPriority = z.object({priority: coreFeePriority, type: z.literal("Priority")});

export const coreStellarFeeStrategySpecifiedRate = z.object({baseFee: z.string(), type: z.literal("SpecifiedRate")});

export const coreStellarFeeStrategy = z.discriminatedUnion("type", [coreStellarFeeStrategyPriority, coreStellarFeeStrategySpecifiedRate]);

export const coreTransactionOrderParametersStellar = z.object({operation: coreStellarOperation, memo: coreStellarMemo.optional(), feeStrategy: coreStellarFeeStrategy, maximumFee: z.string().optional(), type: z.literal("Stellar")});

export const coreSubstrateBalancesMethod = z.object({destination: coreTransactionDestination, amount: z.string(), type: z.literal("TransferKeepAlive")});

export const coreSubstratePalletBalances = z.object({method: coreSubstrateBalancesMethod, type: z.literal("Balances")});

export const coreSubstrateStakingPayeeAccount = z.object({destination: coreTransactionDestination, type: z.literal("Account")});

export const coreSubstrateStakingPayeeController = z.object({type: z.literal("Controller")});

export const coreSubstrateStakingPayeeStaked = z.object({type: z.literal("Staked")});

export const coreSubstrateStakingPayeeStash = z.object({type: z.literal("Stash")});

export const coreSubstrateStakingPayee = z.discriminatedUnion("type", [coreSubstrateStakingPayeeAccount, coreSubstrateStakingPayeeController, coreSubstrateStakingPayeeStaked, coreSubstrateStakingPayeeStash]);

export const coreSubstrateStakingMethodBond = z.object({controller: coreTransactionDestination.optional(), value: z.string(), payee: coreSubstrateStakingPayee, type: z.literal("Bond")});

export const coreSubstrateStakingMethodBondExtra = z.object({maxAdditional: z.string(), type: z.literal("BondExtra")});

export const coreSubstrateStakingMethodChill = z.object({type: z.literal("Chill")});

export const coreSubstrateStakingMethodNominate = z.object({targets: z.array(coreTransactionDestination), type: z.literal("Nominate")});

export const coreSubstrateStakingMethodRebond = z.object({value: z.string(), type: z.literal("Rebond")});

export const coreSubstrateStakingMethodSetController = z.object({controller: coreTransactionDestination.optional(), type: z.literal("SetController")});

export const coreSubstrateStakingMethodSetPayee = z.object({payee: coreSubstrateStakingPayee, type: z.literal("SetPayee")});

export const coreSubstrateStakingMethodUnbond = z.object({value: z.string(), type: z.literal("Unbond")});

export const coreSubstrateStakingMethodWithdrawUnbonded = z.object({numSlashingSpans: z.number().int(), type: z.literal("WithdrawUnbonded")});

export const coreSubstrateStakingMethod = z.discriminatedUnion("type", [coreSubstrateStakingMethodBond, coreSubstrateStakingMethodBondExtra, coreSubstrateStakingMethodChill, coreSubstrateStakingMethodNominate, coreSubstrateStakingMethodRebond, coreSubstrateStakingMethodSetController, coreSubstrateStakingMethodSetPayee, coreSubstrateStakingMethodUnbond, coreSubstrateStakingMethodWithdrawUnbonded]);

export const coreSubstratePalletStaking = z.object({method: coreSubstrateStakingMethod, type: z.literal("Staking")});

export const coreSubstratePallet = z.discriminatedUnion("type", [coreSubstratePalletBalances, coreSubstratePalletStaking]);

export const coreSubstrateFeeStrategy = z.object({priority: coreFeePriority, type: z.literal("Priority")});

export const coreTransactionOrderParametersSubstrate = z.object({pallet: coreSubstratePallet, feeStrategy: coreSubstrateFeeStrategy, maximumFee: z.string().optional(), type: z.literal("Substrate")});

export const coreTezosOperationDelegation = z.object({destination: coreTransactionDestination, type: z.literal("Delegation")});

export const coreTezosOperationReveal = z.object({type: z.literal("Reveal")});

export const coreContractParameters = z.object({value: z.string(), type: z.literal("Raw")});

export const coreTezosOperationTransaction = z.object({destination: coreTransactionDestination, amount: z.string(), contractParameters: coreContractParameters.optional(), type: z.literal("Transaction")});

export const coreTezosOperationUndelegation = z.object({type: z.literal("Undelegation")});

export const coreTezosOperation = z.discriminatedUnion("type", [coreTezosOperationDelegation, coreTezosOperationReveal, coreTezosOperationTransaction, coreTezosOperationUndelegation]);

export const coreTezosFeeStrategy = z.object({priority: coreFeePriority, type: z.literal("Priority")});

export const coreTransactionOrderParametersTezos = z.object({operation: coreTezosOperation, feeStrategy: coreTezosFeeStrategy, maximumFee: z.string().optional(), type: z.literal("Tezos")});

export const coreTronFeeStrategy = z.object({priority: coreFeePriority, type: z.literal("Priority")});

export const coreTronOperationNativeTransfer = z.object({destination: coreTransactionDestination, amount: z.string(), type: z.literal("NativeTransfer")});

export const coreTronOperationTRC20Transfer = z.object({destination: coreTransactionDestination, amount: z.string(), contractAddress: z.string().min(1).max(512), type: z.literal("TRC20Transfer")});

export const coreTronOperation = z.discriminatedUnion("type", [coreTronOperationNativeTransfer, coreTronOperationTRC20Transfer]);

export const coreTransactionOrderParametersTron = z.object({feeStrategy: coreTronFeeStrategy, maximumFee: z.string().optional(), operation: coreTronOperation, type: z.literal("Tron")});

export const coreXrplFeeStrategyPriority = z.object({priority: coreFeePriority, type: z.literal("Priority")});

export const coreXrplFeeStrategySpecifiedAdditionalFee = z.object({drops: z.string(), type: z.literal("SpecifiedAdditionalFee")});

export const coreXrplFeeStrategy = z.discriminatedUnion("type", [coreXrplFeeStrategyPriority, coreXrplFeeStrategySpecifiedAdditionalFee]);

export const coreXrplMemo = z.object({memoData: z.string().optional(), memoFormat: z.string().optional(), memoType: z.string().optional()});

export const coreXrplAccountSetFlag = z.enum(["asfGlobalFreeze", "asfNoFreeze", "asfRequireAuth", "asfAllowTrustLineClawback", "asfAccountTxnID", "asfDepositAuth", "asfRequireDest", "asfDefaultRipple"]);

export const coreXrplOperationAccountSet = z.object({setFlag: coreXrplAccountSetFlag.optional(), clearFlag: coreXrplAccountSetFlag.optional(), transferRate: z.number().int().optional(), type: z.literal("AccountSet")});

export const coreXrplClawbackCurrencyCurrency = z.object({code: z.string().min(1).max(100), issuer: z.string().min(25).max(35), type: z.literal("Currency")});

export const coreXrplClawbackCurrencyMultiPurposeToken = z.object({issuanceId: z.string(), type: z.literal("MultiPurposeToken")});

export const coreXrplClawbackCurrencyTickerId = z.object({tickerId: z.string(), type: z.literal("TickerId")});

export const coreXrplClawbackCurrency = z.discriminatedUnion("type", [coreXrplClawbackCurrencyCurrency, coreXrplClawbackCurrencyMultiPurposeToken, coreXrplClawbackCurrencyTickerId]);

export const coreXrplOperationClawback = z.object({currency: coreXrplClawbackCurrency, holder: coreTransactionDestination, value: z.string(), type: z.literal("Clawback")});

export const coreXrplOperationDepositPreauth = z.object({authorize: coreTransactionDestination.optional(), unauthorize: coreTransactionDestination.optional(), type: z.literal("DepositPreauth")});

export const coreXrplOperationEscrowFinish = z.object({owner: coreTransactionDestination, offerSequence: z.number().int().gte(0).lte(4294967295), condition: z.string().optional(), credentialIds: z.array(z.string()).optional(), fulfillment: z.string().optional(), type: z.literal("EscrowFinish")});

export const coreXrplMPTokenIdentifierMPTokenIssuanceId = z.object({issuanceId: z.string(), type: z.literal("MPTokenIssuanceId")});

export const coreXrplMPTokenIdentifierTickerId = z.object({tickerId: z.string(), type: z.literal("TickerId")});

export const coreXrplMPTokenIdentifier = z.discriminatedUnion("type", [coreXrplMPTokenIdentifierMPTokenIssuanceId, coreXrplMPTokenIdentifierTickerId]);

export const coreXrplMPTokenAuthorizeFlag = z.literal("tfMPTUnauthorize");

export const coreXrplOperationMPTokenAuthorize = z.object({tokenIdentifier: coreXrplMPTokenIdentifier, flags: z.array(coreXrplMPTokenAuthorizeFlag), holder: coreTransactionDestination.optional(), type: z.literal("MPTokenAuthorize")});

export const coreXrplMPTokenIssuanceCreateFlag = z.enum(["tfMPTRequireAuth", "tfMPTCanClawback", "tfMPTCanTransfer", "tfMPTCanEscrow", "tfMPTCanLock", "tfMPTCanTrade"]);

export const coreMPTokenIssuanceMetadata = z.object({value: z.string(), type: z.literal("HexEncodedMetadata")});

export const coreXrplOperationMPTokenIssuanceCreate = z.object({flags: z.array(coreXrplMPTokenIssuanceCreateFlag), assetScale: z.number().int().gte(0).lte(255).optional(), transferFee: z.number().int().gte(0).lte(50000).optional(), maximumAmount: z.string().optional(), metadata: coreMPTokenIssuanceMetadata.optional(), type: z.literal("MPTokenIssuanceCreate")});

export const coreXrplOperationMPTokenIssuanceDestroy = z.object({tokenIdentifier: coreXrplMPTokenIdentifier, type: z.literal("MPTokenIssuanceDestroy")});

export const coreXrplMPTokenIssuanceSetFlag = z.enum(["tfMPTLock", "tfMPTUnlock"]);

export const coreXrplOperationMPTokenIssuanceSet = z.object({tokenIdentifier: coreXrplMPTokenIdentifier, holder: coreTransactionDestination.optional(), flags: z.array(coreXrplMPTokenIssuanceSetFlag), type: z.literal("MPTokenIssuanceSet")});

export const coreXrplOfferCreateFlag = z.enum(["tfImmediateOrCancel", "tfFillOrKill", "tfSell"]);

export const coreXrplIouCurrencyCurrency = z.object({code: z.string().min(1).max(100), issuer: z.string().min(25).max(35), type: z.literal("Currency")});

export const coreXrplIouCurrencyTickerId = z.object({tickerId: z.string(), type: z.literal("TickerId")});

export const coreXrplIouCurrency = z.discriminatedUnion("type", [coreXrplIouCurrencyCurrency, coreXrplIouCurrencyTickerId]);

export const coreXrplAssetQuantity = z.object({currency: coreXrplIouCurrency.optional(), amount: z.string()});

export const coreXrplOperationOfferCreate = z.object({flags: z.array(coreXrplOfferCreateFlag), takerGets: coreXrplAssetQuantity, takerPays: coreXrplAssetQuantity, type: z.literal("OfferCreate")});

export const coreXrplPaymentCurrencyCurrency = z.object({code: z.string().min(1).max(100), issuer: z.string().min(25).max(35), type: z.literal("Currency")});

export const coreXrplPaymentCurrencyMultiPurposeToken = z.object({issuanceId: z.string(), type: z.literal("MultiPurposeToken")});

export const coreXrplPaymentCurrencyTickerId = z.object({tickerId: z.string(), type: z.literal("TickerId")});

export const coreXrplPaymentCurrency = z.discriminatedUnion("type", [coreXrplPaymentCurrencyCurrency, coreXrplPaymentCurrencyMultiPurposeToken, coreXrplPaymentCurrencyTickerId]);

export const coreXrplOperationPayment = z.object({destination: coreTransactionDestination, amount: z.string(), destinationTag: z.number().int().gte(0).lte(4294967295).optional(), currency: coreXrplPaymentCurrency.optional(), type: z.literal("Payment")});

export const coreXrplTrustSetFlag = z.enum(["tfSetFreeze", "tfClearFreeze", "tfSetfAuth"]);

export const coreXrplLimitAmount = z.object({currency: coreXrplIouCurrency, value: z.string()});

export const coreXrplOperationTrustSet = z.object({flags: z.array(coreXrplTrustSetFlag), limitAmount: coreXrplLimitAmount, enableRippling: z.boolean().optional(), type: z.literal("TrustSet")});

export const coreXrplOperation = z.discriminatedUnion("type", [coreXrplOperationAccountSet, coreXrplOperationClawback, coreXrplOperationDepositPreauth, coreXrplOperationEscrowFinish, coreXrplOperationMPTokenAuthorize, coreXrplOperationMPTokenIssuanceCreate, coreXrplOperationMPTokenIssuanceDestroy, coreXrplOperationMPTokenIssuanceSet, coreXrplOperationOfferCreate, coreXrplOperationPayment, coreXrplOperationTrustSet]);

export const coreTransactionOrderParametersXRPL = z.object({destination: coreTransactionDestination.optional(), amount: z.string().optional(), feeStrategy: coreXrplFeeStrategy, maximumFee: z.string().optional(), sourceTag: z.number().int().gte(0).lte(4294967295).optional(), destinationTag: z.number().int().gte(0).lte(4294967295).optional(), memos: z.array(coreXrplMemo), operation: coreXrplOperation.optional(), type: z.literal("XRPL")});

export const coreTransactionOrderParameters = z.discriminatedUnion("type", [coreTransactionOrderParametersAlgorand, coreTransactionOrderParametersBitcoin, coreTransactionOrderParametersBitcoinRedirect, coreTransactionOrderParametersCardano, coreTransactionOrderParametersEthereum, coreTransactionOrderParametersHedera, coreTransactionOrderParametersSolana, coreTransactionOrderParametersStellar, coreTransactionOrderParametersSubstrate, coreTransactionOrderParametersTezos, coreTransactionOrderParametersTron, coreTransactionOrderParametersXRPL]);

export const coreUserReference = z.object({id: z.string(), domainId: z.string()});

export const coreStringsMap = z.record(z.string(), z.string());

export const coreEntityMetadata = z.object({description: z.string().max(250).optional(), revision: z.number().int().gte(1), createdAt: z.string(), createdBy: coreUserReference.optional(), lastModifiedAt: z.string(), lastModifiedBy: coreUserReference.optional(), customProperties: coreStringsMap});

export const coreTransactionOrder = z.object({id: z.string(), domainId: z.string(), accountId: z.string(), ledgerId: z.string().min(1).max(100).optional(), parameters: coreTransactionOrderParameters, metadata: coreEntityMetadata});

export const coreTrustedTransactionOrder = z.object({data: coreTransactionOrder, signature: z.string(), signingKey: z.string()});

export const coreTrustedTransactionOrdersCollection = z.object({items: z.array(coreTrustedTransactionOrder), count: z.number().int(), currentStartingAfter: z.string().optional(), nextStartingAfter: z.string().optional()});

export const validateResponse = async <Output>(
  schema: {
    readonly '~standard': {
      readonly validate: (value: unknown) => ({ readonly value: Output; readonly issues?: undefined } | { readonly issues: ReadonlyArray<{ readonly message: string; readonly path?: ReadonlyArray<PropertyKey | { readonly key: PropertyKey }> | undefined }> }) | Promise<{ readonly value: Output; readonly issues?: undefined } | { readonly issues: ReadonlyArray<{ readonly message: string; readonly path?: ReadonlyArray<PropertyKey | { readonly key: PropertyKey }> | undefined }> }>
    }
  },
  value: unknown
): Promise<Output> => {
  const result = await schema['~standard'].validate(value)

  if (result.issues !== undefined) {
    const detail = result.issues
      .map(({ message, path }) =>
        path?.length
          ? `${path.map((segment) => String(typeof segment === 'object' ? segment.key : segment)).join('.')}: ${message}`
          : message
      )
      .join('; ')

    throw new Error(`Response does not match the schema: ${detail}`, { cause: { issues: result.issues } })
  }

  return result.value
};

/**
 * List transaction orders
 * 
 * GET /v1/domains/{domainId}/transactions/orders
 */
export const getApiV1DomainsDomainIdTransactionsOrders = async (args: GetApiV1DomainsDomainIdTransactionsOrdersArgs, options: GetApiV1DomainsDomainIdTransactionsOrdersOptions) => {
const {baseUrl, fetch: fetchFn = fetch, httpAuth} = options ?? {}

const query = new URLSearchParams()
const headers = new Headers()
headers.set('accept', "application/json")

if (args.limit != null) query.append("limit", String(args.limit))
if (args.startingAfter != null) query.append("startingAfter", String(args.startingAfter))
if (args.sortBy != null) query.append("sortBy", String(args.sortBy))
if (args.sortOrder != null) query.append("sortOrder", String(args.sortOrder))
for (const item of args.accountId ?? []) query.append("accountId", String(item))
for (const item of args.ledgerId ?? []) query.append("ledgerId", String(item))
if (args.intentId != null) query.append("intentId", String(args.intentId))
if (args['parameters.type'] != null) query.append("parameters.type", String(args['parameters.type']))
if (args['metadata.createdBy'] != null) query.append("metadata.createdBy", String(args['metadata.createdBy']))
if (args['metadata.lastModifiedBy'] != null) query.append("metadata.lastModifiedBy", String(args['metadata.lastModifiedBy']))
if (args['metadata.createdAt.lt'] != null) query.append("metadata.createdAt.lt", String(args['metadata.createdAt.lt']))
if (args['metadata.createdAt.gt'] != null) query.append("metadata.createdAt.gt", String(args['metadata.createdAt.gt']))
if (args['metadata.lastModifiedAt.lt'] != null) query.append("metadata.lastModifiedAt.lt", String(args['metadata.lastModifiedAt.lt']))
if (args['metadata.lastModifiedAt.gt'] != null) query.append("metadata.lastModifiedAt.gt", String(args['metadata.lastModifiedAt.gt']))
if (args['metadata.description'] != null) query.append("metadata.description", String(args['metadata.description']))
for (const item of args['metadata.customProperties'] ?? []) query.append("metadata.customProperties", String(item))
if (httpAuth !== undefined) headers.set('authorization', `Bearer ${httpAuth}`)

const url = `${baseUrl.replace(/\/+$/, '')}/v1/domains/${encodeURIComponent(String(args.domainId))}/transactions/orders${query.size > 0 ? `?${query}` : ''}`

const res = await fetchFn(url, {method: "GET", headers})

if (!res.ok) throw new Error(`Request failed with status ${res.status}`, {cause: {status: res.status, body: await res.text()}})

return validateResponse(coreTrustedTransactionOrdersCollection, await res.json())
};