import {z} from 'zod'

export type V2StellarTransactionMemoTypeEnum = 'TEXT' | 'ID' | 'HASH' | 'RETURN';

export type V2StellarTransactionMemo = {type: V2StellarTransactionMemoTypeEnum, data: string};

export type AssetTransferStellarOptions = {memo?: V2StellarTransactionMemo | undefined};

export type AssetTransferXRPLOptions = {destinationTag?: string | undefined};

export type V2AssetTransfer = {asset: string, amount: string, source: string, destination: string, payFeeFromAmount?: boolean | undefined, memo?: string | undefined, sponsor?: string | undefined, stellarOptions?: AssetTransferStellarOptions | undefined, xrplOptions?: AssetTransferXRPLOptions | undefined};

export type BatchAssetTransferBatchTransferDestination = {destination: string, amount: string, note?: string | undefined};

export type V2BatchAssetTransfer = {asset: string, source: string, destinations: Array<BatchAssetTransferBatchTransferDestination>};

export type V2EVMPriority = {gasLimit?: unknown | undefined, gasPrice?: string | undefined, maxPriorityFeePerGas?: string | undefined, maxFeePerGas?: string | undefined};

export type V2EVMTransactionParams = {gasSettings?: V2EVMPriority | undefined, nonce?: string | undefined};

export type Apiv2EVMTransactionAuthorization = {address: string, chainId: string, nonce: unknown, signature: string};

export type Apiv2EVMTransactionAuthorizationDetails = {authorizationList: Array<Apiv2EVMTransactionAuthorization>};

export type Apiv2EVMTransaction = {network: string, fromAddress: string, toAddress?: string | undefined, value?: string | undefined, data?: string | undefined, overrideParams?: V2EVMTransactionParams | undefined, authorizationDetails?: Apiv2EVMTransactionAuthorizationDetails | undefined, publish?: boolean | undefined, sponsor?: string | undefined};

export type V2EVMPersonalSign = {fromAddress: string, message?: string | undefined, messageHex?: string | undefined};

export type V2EVMSignTypedDataV4 = {fromAddress: string, message: string};

export type Apiv2EVMAccountDelegation = {fromAddress: string, contractAddress: string, chainId?: string | undefined, nonce?: unknown | undefined, offsetNonce?: boolean | undefined};

export type V2EVMZamaConfidentialShield = {source: string, asset: string, amount: string};

export type V2EVMZamaConfidentialActivation = {wallet: string, network: string, confidentialTokens: Array<string>};

export type Apiv2ExchangeWithdrawal = {asset: string, amount: string, source: string, destination: string, destinationNetwork: string, payFeeFromAmount?: boolean | undefined};

export type V2SolanaSerializedTransaction = {network: string, rawTransaction: string, publish?: boolean | undefined, replaceBlockhash?: boolean | undefined, tryReplaceBlockhash?: boolean | undefined};

export type V2TronTriggerSmartContract = {network: string, ownerAddress: string, contractAddress: string, callValue?: unknown | undefined, data?: string | undefined};

export type Apiv2TronTransactionTriggerSmartContract = {ownerAddress: string, contractAddress: string, callValue?: unknown | undefined, data?: string | undefined};

export type Apiv2TronTransactionTronResourceEnum = 'BANDWIDTH' | 'ENERGY';

export type Apiv2TronTransactionFreezeBalanceV2 = {ownerAddress: string, amount: string, resource: Apiv2TronTransactionTronResourceEnum};

export type Apiv2TronTransactionUnfreezeBalanceV2 = {ownerAddress: string, amount: string, resource: Apiv2TronTransactionTronResourceEnum};

export type Apiv2TronTransactionWithdrawExpireUnfreeze = {ownerAddress: string};

export type Apiv2TronTransactionDelegateResource = {ownerAddress: string, resource: Apiv2TronTransactionTronResourceEnum, amount: string, receiverAddress: string, lock?: boolean | undefined, lockPeriod?: string | undefined};

export type Apiv2TronTransactionUnDelegateResource = {ownerAddress: string, resource: Apiv2TronTransactionTronResourceEnum, amount: string, receiverAddress: string};

export type Apiv2TronTransactionCancelAllUnfreezeV2 = {ownerAddress: string};

export type Apiv2TronTransactionVoteWitnessVote = {voteAddress: string, voteCount: string};

export type Apiv2TronTransactionVoteWitness = {ownerAddress: string, votes: Array<Apiv2TronTransactionVoteWitnessVote>};

export type Apiv2TronTransactionWithdrawBalance = {ownerAddress: string};

export type Apiv2TronTransaction = {network: string, publish?: boolean | undefined, triggerSmartContract?: Apiv2TronTransactionTriggerSmartContract | undefined, freezeBalanceV2?: Apiv2TronTransactionFreezeBalanceV2 | undefined, unfreezeBalanceV2?: Apiv2TronTransactionUnfreezeBalanceV2 | undefined, withdrawExpireUnfreeze?: Apiv2TronTransactionWithdrawExpireUnfreeze | undefined, delegateResource?: Apiv2TronTransactionDelegateResource | undefined, undelegateResource?: Apiv2TronTransactionUnDelegateResource | undefined, cancelAllUnfreezeV2?: Apiv2TronTransactionCancelAllUnfreezeV2 | undefined, voteWitness?: Apiv2TronTransactionVoteWitness | undefined, withdrawBalance?: Apiv2TronTransactionWithdrawBalance | undefined};

export type Apiv2TronPersonalSign = {fromAddress: string, message?: string | undefined, messageHex?: string | undefined};

export type Apiv2SolanaSignMessage = {signer: string, message?: string | undefined};

export type V2SuiRawTransaction = {network: string, sender: string, txBcsBytes: string, publish?: boolean | undefined};

export type V2XRPLRawTransaction = {network: string, sender: string, jsonTransactionData: Record<string, never>, publish?: boolean | undefined};

export type V2StellarRawTransaction = {network: string, sourceAddress: string, xdrEnvelope: string, publish?: boolean | undefined, useLatestSequenceNumber?: boolean | undefined};

export type OperationBodyPayment = {destinationAddress: string, asset: string, rawAmount: string};

export type OperationBodyCreateAccount = {destinationAddress: string, rawStartingBalance: string};

export type OperationBodyChangeTrust = {asset: string, limit?: string | undefined};

export type OperationBodySEP41Payment = {spenderAddress?: string | undefined, sourceAddress: string, destinationAddress: string, contractAddress: string, rawAmount: string};

export type OperationBodySEP41TokenApproval = {sourceAddress: string, spenderAddress: string, contractAddress: string, rawAmount: string, liveUntilLedgerNumber: unknown};

export type OperationBody = {raw?: string | undefined, payment?: OperationBodyPayment | undefined, createAccount?: OperationBodyCreateAccount | undefined, changeTrust?: OperationBodyChangeTrust | undefined, sep41Payment?: OperationBodySEP41Payment | undefined, sep41TokenApproval?: OperationBodySEP41TokenApproval | undefined};

export type V2StellarTransactionOperation = {sourceAccountAddress?: string | undefined, body: OperationBody};

export type Apiv2StellarTimeBounds = {minUnixTime?: unknown | undefined, maxUnixTime: unknown};

export type Apiv2StellarTransaction = {network: string, sourceAddress: string, operations: Array<V2StellarTransactionOperation>, memo?: V2StellarTransactionMemo | undefined, fee?: unknown | undefined, timeBounds?: Apiv2StellarTimeBounds | undefined, publish?: boolean | undefined};

export type EVMUtilaDelegatedCallsCallRaw = {toAddress: string, value?: string | undefined, data?: string | undefined};

export type V2EVMUtilaDelegatedCallsCall = {raw: EVMUtilaDelegatedCallsCallRaw};

export type V2EVMUtilaDelegatedCallsSubmissionDetails = {sponsorAddress?: string | undefined};

export type V2EVMUtilaDelegatedCalls = {network?: string | undefined, fromAddress?: string | undefined, calls?: Array<V2EVMUtilaDelegatedCallsCall> | undefined, deadlineUnix?: string | undefined, submissionDetails?: V2EVMUtilaDelegatedCallsSubmissionDetails | undefined};

export type Apiv2BTCPSBT = {network: string, psbt: string};

export type V2BTCTransferUTXO = {txHash: string, vout: number};

export type BTCTransferInputSource = {source: string};

export type BTCTransferOutput = {destination: string, amount: string, payFeeFromAmount?: boolean | undefined};

export type BTCTransferChangeOutput = {address: string};

export type BTCTransferFeeSettings = {feeRate: string};

export type V2BTCTransfer = {network: string, inputs?: Array<V2BTCTransferUTXO> | undefined, inputSources?: Array<BTCTransferInputSource> | undefined, outputs: Array<BTCTransferOutput>, changeOutputs?: Array<BTCTransferChangeOutput> | undefined, feeSettings?: BTCTransferFeeSettings | undefined};

export type V2InitiateTransactionRequestDetails = {assetTransfer?: V2AssetTransfer | undefined, assetBatchTransfer?: V2BatchAssetTransfer | undefined, evmTransaction?: Apiv2EVMTransaction | undefined, evmPersonalSign?: V2EVMPersonalSign | undefined, evmSignTypedDataV4?: V2EVMSignTypedDataV4 | undefined, evmAccountDelegation?: Apiv2EVMAccountDelegation | undefined, evmZamaConfidentialShield?: V2EVMZamaConfidentialShield | undefined, evmZamaConfidentialActivation?: V2EVMZamaConfidentialActivation | undefined, exchangeWithdrawal?: Apiv2ExchangeWithdrawal | undefined, solanaSerializedTransaction?: V2SolanaSerializedTransaction | undefined, tronTriggerSmartContract?: V2TronTriggerSmartContract | undefined, tronTransaction?: Apiv2TronTransaction | undefined, tronPersonalSign?: Apiv2TronPersonalSign | undefined, solanaSignMessage?: Apiv2SolanaSignMessage | undefined, suiRawTransaction?: V2SuiRawTransaction | undefined, xrplRawTransaction?: V2XRPLRawTransaction | undefined, stellarRawTransaction?: V2StellarRawTransaction | undefined, stellarTransaction?: Apiv2StellarTransaction | undefined, evmUtilaDelegatedCalls?: V2EVMUtilaDelegatedCalls | undefined, btcPsbt?: Apiv2BTCPSBT | undefined, btcTransfer?: V2BTCTransfer | undefined};

export type V2TransactionPriorityEnum = 'LOW' | 'NORMAL' | 'HIGH';

export type TransactionsInitiateTransactionBody = {details: V2InitiateTransactionRequestDetails, priority?: V2TransactionPriorityEnum | undefined, note?: string | undefined, designatedSigners?: Array<string> | undefined, validateOnly?: boolean | undefined, requestId?: string | undefined, externalId?: string | undefined, annotations?: {[key: string]: string} | undefined, runSimulation?: boolean | undefined, skipInitiatorApproval?: boolean | undefined, expireTime?: string | undefined, includeReferencedResources?: boolean | undefined};

export type CreateApiV2VaultsVaultIdTransactionsInitiateArgs = {vault_id: string, body: TransactionsInitiateTransactionBody};

export type CreateApiV2VaultsVaultIdTransactionsInitiateOptions = {baseUrl?: string | undefined, bearerAuth?: string | undefined, fetch?: typeof fetch | undefined};

export const v2TransactionTypeEnum = z.enum(["TRANSACTION", "MESSAGE"]);

export const v2TransactionSubTypeEnum = z.enum(["NATIVE_TRANSFER", "TOKEN_TRANSFER", "NON_FUNGIBLE_TOKEN_TRANSFER", "TOKEN_APPROVAL", "PERSONAL_SIGN", "SIGN_TYPED_DATA", "EVM_ACCOUNT_DELEGATION", "CONTRACT_CALL", "NATIVE_MULTI_TRANSFER", "NON_FUNGIBLE_TOKEN_APPROVAL", "CONNECTION_TRANSFER", "BATCH_TRANSFER", "TOKEN_MINT", "TOKEN_BURN", "PROGRAM_CALL", "CONTRACT_DEPLOYMENT", "TON_PROOF", "TON_SIGN_DATA", "SOLANA_SIGN_MESSAGE", "GENERIC_TRANSACTION", "CHANGE_TRUST", "CANTON_TOPOLOGY_TRANSACTION", "CANTON_TRANSFER_AUTO_APPROVAL", "CANTON_ACCEPT_TRANSFER_OFFER", "SUBMITTING_TRANSACTION", "BTC_PSBT", "BTC_TRANSFER", "BTC_SIGN_MESSAGE", "SHIELD", "UNSHIELD", "ALEO_CONSOLIDATE", "EVM_ZAMA_CONFIDENTIAL_TOKEN_ACTIVATION"]);

export const v2TransactionStateEnum = z.enum(["AWAITING_APPROVAL", "AWAITING_AML_POLICY_CHECK", "DECLINED_BY_AML_POLICY", "AWAITING_POLICY_CHECK", "AWAITING_SIGNATURE", "SIGNED", "AWAITING_PUBLISH", "PUBLISHED", "MINED", "MINED_FAILED", "FAILED", "DECLINED", "REPLACED", "CANCELED", "DROPPED", "CONFIRMED", "EXPIRED"]);

export const protobufAny = z.object({"@type": z.string().optional()}).and(z.record(z.string(), z.unknown()));

export const googlerpcStatus = z.object({code: z.number().int().optional(), message: z.string().optional(), details: z.array(protobufAny).optional()});

export const v2TransactionDirectionEnum = z.enum(["INCOMING", "OUTGOING"]);

export const transactionRequestDappInfo = z.object({url: z.string().optional()});

export const transactionRequestOriginEnum = z.enum(["WALLET_CONNECT", "EXTENSION"]);

export const v2RequestSignature = z.object({rawRequestBody: z.string().optional(), jwt: z.string().optional()});

export const v2TransactionRequest = z.object({name: z.string().optional(), externalId: z.string().optional(), initiator: z.string().optional(), sourceWallet: z.string().optional(), cancelTime: z.string().optional(), signTime: z.string().optional(), failTime: z.string().optional(), declineTime: z.string().optional(), publishTime: z.string().optional(), dropTime: z.string().optional(), expireTime: z.string().optional(), approveTime: z.string().optional(), publish: z.boolean().optional(), signingSessions: z.array(z.string()).optional(), blockingTransaction: z.string().optional(), walletconnectSession: z.string().optional(), transactionBundle: z.string().optional(), evmSubmissionDetails: z.string().optional(), dappInfo: transactionRequestDappInfo.optional(), origin: transactionRequestOriginEnum.optional(), gasStationOrder: z.string().optional(), gasStation: z.string().optional(), sponsorWallet: z.string().optional(), initiatorRequestSignature: v2RequestSignature.optional()});

export const v2ScreeningStateEnum = z.enum(["SKIPPED", "PENDING", "FAILED", "READY"]);

export const v2AMLActionEnum = z.enum(["DENY", "ALLOW", "ALERT"]);

export const transactionAMLDetails = z.object({screeningState: v2ScreeningStateEnum.optional(), screeningPolicyResult: v2AMLActionEnum.optional(), resolved: z.boolean().optional()});

export const apiv2Address = z.object({value: z.string().optional(), infoRef: z.string().optional(), private: z.boolean().optional()});

export const v2ConvertedValue = z.object({amount: z.string().optional(), currencyCode: z.string().optional()});

export const transactionTransfer = z.object({sourceAddress: apiv2Address.optional(), destinationAddress: apiv2Address.optional(), amount: z.string().optional(), asset: z.string().optional(), miningPrice: v2ConvertedValue.optional(), note: z.string().optional(), unknownAmount: z.boolean().optional()});

export const transactionTokenAllowance = z.object({approverAddress: apiv2Address.optional(), spenderAddress: apiv2Address.optional(), asset: z.string().optional(), amount: z.string().optional(), miningPrice: v2ConvertedValue.optional()});

export const v2EVMTransactionGas = z.object({gasLimit: z.string().optional(), gasUsed: z.string().optional(), gasPrice: z.string().optional(), maxPriorityFeePerGas: z.string().optional(), maxFeePerGas: z.string().optional()});

export const v2TransactionEVMTransactionAuthorization = z.object({signer: apiv2Address.optional(), contractAddress: apiv2Address.optional(), nonce: z.string().optional(), chainId: z.string().optional(), signature: z.string().optional()});

export const v2TransactionEVMTransactionAuthorizationDetails = z.object({authorizationList: z.array(v2TransactionEVMTransactionAuthorization).optional()});

export const v2TransactionEVMTransaction = z.object({fromAddress: apiv2Address.optional(), toAddress: apiv2Address.optional(), value: z.string().optional(), data: z.string().optional(), fee: v2EVMTransactionGas.optional(), authorizationDetails: v2TransactionEVMTransactionAuthorizationDetails.optional(), signature: z.string().optional(), providedNonce: z.string().optional(), nonce: z.string().optional(), chainId: z.string().optional()});

export const transactionEVMMessageTypeEnum = z.enum(["PERSONAL_SIGN", "SIGN_TYPED_DATA_V4"]);

export const transactionEVMMessage = z.object({type: transactionEVMMessageTypeEnum.optional(), message: z.string().optional(), signature: z.string().optional()});

export const v2TransactionTronPersonalSign = z.object({message: z.string().optional(), signature: z.string().optional(), messageHex: z.string().optional()});

export const v2TransactionEVMAccountDelegation = z.object({signerAddress: apiv2Address.optional(), contractAddress: apiv2Address.optional(), chainId: z.string().optional(), nonce: z.string().optional(), signature: z.string().optional(), offsetNonce: z.boolean().optional(), providedNonce: z.string().optional()});

export const v2TransactionTronTransactionTriggerSmartContract = z.object({ownerAddress: apiv2Address.optional(), contractAddress: apiv2Address.optional(), callValue: z.string().optional(), data: z.string().optional()});

export const v2TransactionTronTransactionTronResourceEnum = z.enum(["BANDWIDTH", "ENERGY"]);

export const v2TransactionTronTransactionFreezeBalanceV2 = z.object({ownerAddress: apiv2Address.optional(), amount: z.string().optional(), resource: v2TransactionTronTransactionTronResourceEnum.optional(), asset: z.string().optional()});

export const v2TransactionTronTransactionUnfreezeBalanceV2 = z.object({ownerAddress: apiv2Address.optional(), amount: z.string().optional(), resource: v2TransactionTronTransactionTronResourceEnum.optional(), asset: z.string().optional()});

export const v2TransactionTronTransactionWithdrawExpireUnfreeze = z.object({ownerAddress: apiv2Address.optional()});

export const v2TransactionTronTransactionDelegateResource = z.object({ownerAddress: apiv2Address.optional(), resource: v2TransactionTronTransactionTronResourceEnum.optional(), amount: z.string().optional(), asset: z.string().optional(), receiverAddress: apiv2Address.optional(), lock: z.boolean().optional(), lockPeriod: z.string().optional()});

export const v2TransactionTronTransactionUnDelegateResource = z.object({ownerAddress: apiv2Address.optional(), resource: v2TransactionTronTransactionTronResourceEnum.optional(), amount: z.string().optional(), asset: z.string().optional(), receiverAddress: apiv2Address.optional()});

export const v2TransactionTronTransactionCancelAllUnfreezeV2 = z.object({ownerAddress: apiv2Address.optional()});

export const v2TransactionTronTransactionVoteWitnessVote = z.object({voteAddress: apiv2Address.optional(), voteCount: z.string().optional()});

export const v2TransactionTronTransactionVoteWitness = z.object({ownerAddress: apiv2Address.optional(), votes: z.array(v2TransactionTronTransactionVoteWitnessVote)});

export const v2TransactionTronTransactionWithdrawBalance = z.object({ownerAddress: apiv2Address.optional()});

export const tronTransactionTransferContract = z.object({ownerAddress: apiv2Address.optional(), toAddress: apiv2Address.optional(), amount: z.string().optional()});

export const v2TronResourceFee = z.object({consumed: z.string().optional(), burned: z.string().optional(), convertedBurned: v2ConvertedValue.optional()});

export const v2TronAccountActivationFee = z.object({fee: z.string().optional(), convertedFee: v2ConvertedValue.optional()});

export const v2TronGasStationFee = z.object({order: z.string().optional(), price: z.string().optional(), asset: z.string().optional()});

export const v2TronTransactionFee = z.object({usedSun: z.string().optional(), convertedValue: v2ConvertedValue.optional(), bandwidth: v2TronResourceFee.optional(), energy: v2TronResourceFee.optional(), accountActivationFee: v2TronAccountActivationFee.optional(), gasStationFee: v2TronGasStationFee.optional()});

export const v2TransactionTronTransaction = z.object({triggerSmartContract: v2TransactionTronTransactionTriggerSmartContract.optional(), freezeBalanceV2: v2TransactionTronTransactionFreezeBalanceV2.optional(), unfreezeBalanceV2: v2TransactionTronTransactionUnfreezeBalanceV2.optional(), withdrawExpireUnfreeze: v2TransactionTronTransactionWithdrawExpireUnfreeze.optional(), delegateResource: v2TransactionTronTransactionDelegateResource.optional(), undelegateResource: v2TransactionTronTransactionUnDelegateResource.optional(), cancelAllUnfreezeV2: v2TransactionTronTransactionCancelAllUnfreezeV2.optional(), voteWitness: v2TransactionTronTransactionVoteWitness.optional(), withdrawBalance: v2TransactionTronTransactionWithdrawBalance.optional(), transferContract: tronTransactionTransferContract.optional(), fee: v2TronTransactionFee.optional(), signature: z.string().optional(), expireTime: z.string().optional(), refBlockBytes: z.string().optional(), refBlockHash: z.string().optional(), timestamp: z.string().optional()});

export const bTCTransactionUTXOIn = z.object({address: apiv2Address.optional(), amount: z.string().optional(), signingSession: z.string().optional(), userSelected: z.boolean().optional()});

export const bTCTransactionUTXOOut = z.object({address: apiv2Address.optional(), amount: z.string().optional(), change: z.boolean().optional(), changeUserSelected: z.boolean().optional(), vout: z.number().int().optional()});

export const transactionBTCTransaction = z.object({inputs: z.array(bTCTransactionUTXOIn).optional(), outputs: z.array(bTCTransactionUTXOOut).optional(), fee: z.string().optional(), asset: z.string().optional()});

export const v2TransactionBTCPSBT = z.object({signedPsbt: z.string().optional(), inputs: z.array(bTCTransactionUTXOIn).optional(), outputs: z.array(bTCTransactionUTXOOut).optional(), fee: z.string().optional()});

export const v2DecodedAptosEntryFunction = z.object({function: z.string(), typeArguments: z.array(z.string()), arguments: z.array(z.string())});

export const v2DecodedAptosTransactionPayload = z.object({entryFunction: v2DecodedAptosEntryFunction.optional()});

export const transactionAptosTransaction = z.object({sender: apiv2Address.optional(), sequenceNumber: z.string().optional(), payloadBytes: z.string().optional(), decodedPayload: v2DecodedAptosTransactionPayload.optional(), maxGasAmount: z.string().optional(), gasUnitPrice: z.string().optional(), expirationTime: z.string().optional(), chainId: z.string().optional()});

export const transactionSuiTransaction = z.object({sender: apiv2Address.optional(), gasBudget: z.string().optional(), gasPrice: z.string().optional(), expirationEpoch: z.string().optional(), txBcsBytes: z.string().optional(), decodedTransaction: z.string().optional()});

export const v2TransactionSuiSignPersonalMessage = z.object({signer: apiv2Address.optional(), message: z.string().optional(), signature: z.string().optional()});

export const transactionXRPLTransaction = z.object({jsonTransactionData: z.object({}).optional()});

export const decodedCallArg = z.object({name: z.string().optional(), type: z.string().optional(), value: z.string().optional()});

export const substrateTransactionDecodedCall = z.object({pallet: z.string().optional(), palletIndex: z.number().int().optional(), method: z.string().optional(), methodIndex: z.number().int().optional(), args: z.array(decodedCallArg).optional()});

export const transactionSubstrateTransaction = z.object({fromAddress: apiv2Address.optional(), nonce: z.string().optional(), encodedCall: z.string().optional(), call: substrateTransactionDecodedCall.optional(), genesisHash: z.string().optional()});

export const transactionTonTransactionMessage = z.object({address: z.string(), amount: z.string(), payload: z.string().optional(), stateInit: z.string().optional()});

export const transactionTonTransaction = z.object({sender: apiv2Address.optional(), seqno: z.string().optional(), messages: z.array(transactionTonTransactionMessage).optional(), memo: z.string().optional(), validUntil: z.string().optional(), amount: z.string().optional()});

export const v2TransactionTonSignData = z.object({schemaCrc: z.string().optional(), cell: z.string().optional(), publicKey: z.string().optional(), timestamp: z.string().optional(), signature: z.string().optional()});

export const v2TransactionTonProof = z.object({address: z.string().optional(), appDomain: z.string().optional(), payload: z.string().optional(), timestamp: z.string().optional(), signature: z.string().optional()});

export const v2TransactionSolanaSignMessage = z.object({signer: apiv2Address.optional(), message: z.string().optional(), signature: z.string().optional()});

export const v2TransactionSolanaTransaction = z.object({fee: z.string().optional(), rawTransaction: z.string().optional(), utilaSigners: z.array(apiv2Address).optional(), replaceBlockhash: z.boolean().optional(), memo: z.string().optional()});

export const thetaTransactionCoins = z.object({thetaWei: z.string().optional(), tfuelWei: z.string().optional()});

export const thetaTransactionTxInput = z.object({address: apiv2Address.optional(), coins: thetaTransactionCoins.optional()});

export const thetaTransactionTxOutput = z.object({address: apiv2Address.optional(), coins: thetaTransactionCoins.optional()});

export const thetaTransactionSendTransaction = z.object({inputs: z.array(thetaTransactionTxInput).optional(), outputs: z.array(thetaTransactionTxOutput).optional(), fee: thetaTransactionCoins.optional()});

export const transactionThetaTransaction = z.object({sendTransaction: thetaTransactionSendTransaction.optional()});

export const v2StellarMemoMemoTypeEnum = z.enum(["TEXT", "ID", "HASH", "RETURN"]);

export const v2StellarMemo = z.object({type: v2StellarMemoMemoTypeEnum, data: z.string()});

export const transactionStellarTransactionStellarTimeBounds = z.object({minUnixTime: z.string().optional(), maxUnixTime: z.string().optional()});

export const stellarTransactionDecodedOperationBodyPayment = z.object({destinationAddress: apiv2Address.optional(), asset: z.string().optional(), assetRef: z.string().optional(), amount: z.string().optional()});

export const stellarTransactionDecodedOperationBodyCreateAccount = z.object({destinationAddress: apiv2Address.optional(), startingBalance: z.string().optional()});

export const stellarTransactionDecodedOperationBodyChangeTrust = z.object({asset: z.string().optional(), assetRef: z.string().optional(), limit: z.string().optional(), unlimited: z.boolean().optional()});

export const stellarTransactionDecodedOperationBodySEP41Payment = z.object({spenderAddress: apiv2Address.optional(), sourceAddress: apiv2Address.optional(), destinationAddress: apiv2Address.optional(), contractAddress: z.string().optional(), assetRef: z.string().optional(), rawAmount: z.string().optional()});

export const stellarTransactionDecodedOperationBodySEP41TokenApproval = z.object({sourceAddress: apiv2Address.optional(), spenderAddress: apiv2Address.optional(), contractAddress: z.string().optional(), assetRef: z.string().optional(), rawAmount: z.string().optional(), liveUntilLedgerNumber: z.string().optional()});

export const stellarTransactionDecodedOperationBody = z.object({payment: stellarTransactionDecodedOperationBodyPayment.optional(), createAccount: stellarTransactionDecodedOperationBodyCreateAccount.optional(), changeTrust: stellarTransactionDecodedOperationBodyChangeTrust.optional(), sep41Payment: stellarTransactionDecodedOperationBodySEP41Payment.optional(), sep41TokenApproval: stellarTransactionDecodedOperationBodySEP41TokenApproval.optional()});

export const stellarTransactionStellarOperation = z.object({sourceAccountAddress: apiv2Address.optional(), rawBody: z.string().optional(), decodedBody: stellarTransactionDecodedOperationBody.optional()});

export const v2TransactionStellarTransaction = z.object({sourceAccountAddress: apiv2Address.optional(), sequenceNumber: z.string().optional(), fee: z.string().optional(), memo: v2StellarMemo.optional(), timeBounds: transactionStellarTransactionStellarTimeBounds.optional(), operations: z.array(stellarTransactionStellarOperation).optional(), rawXdrEnvelope: z.string().optional()});

export const transactionFeePublic = z.object({amountMicrocredits: z.string().optional(), priorityFeeMicrocredits: z.string().optional(), payer: apiv2Address.optional()});

export const transactionTransferPublic = z.object({sender: apiv2Address.optional(), recipient: apiv2Address.optional(), amount: z.string().optional()});

export const transactionTransferPublicAsSigner = z.object({signer: apiv2Address.optional(), recipient: apiv2Address.optional(), amount: z.string().optional()});

export const transactionTransferPrivate = z.object({sender: apiv2Address.optional(), recipient: apiv2Address.optional(), sentAmount: z.string().optional(), changeAmount: z.string().optional()});

export const transactionTransferPrivateToPublic = z.object({sender: apiv2Address.optional(), recipient: apiv2Address.optional(), sentAmount: z.string().optional(), changeAmount: z.string().optional()});

export const transactionTransferPublicToPrivate = z.object({sender: apiv2Address.optional(), recipient: apiv2Address.optional(), amount: z.string().optional()});

export const transactionAleoRecord = z.object({commitment: z.string().optional(), amount: z.string().optional()});

export const transactionJoinOperation = z.object({owner: apiv2Address.optional(), inputs: z.array(transactionAleoRecord).optional(), outputs: z.array(transactionAleoRecord).optional()});

export const transactionTransitionValue = z.object({type: z.string().optional(), value: z.string().optional()});

export const transactionUnknownOperation = z.object({inputs: z.array(transactionTransitionValue).optional(), outputs: z.array(transactionTransitionValue).optional()});

export const transactionAleoOperation = z.object({program: z.string().optional(), function: z.string().optional(), asset: z.string().optional(), internal: z.boolean().optional(), transferPublic: transactionTransferPublic.optional(), transferPublicAsSigner: transactionTransferPublicAsSigner.optional(), transferPrivate: transactionTransferPrivate.optional(), transferPrivateToPublic: transactionTransferPrivateToPublic.optional(), transferPublicToPrivate: transactionTransferPublicToPrivate.optional(), join: transactionJoinOperation.optional(), unknown: transactionUnknownOperation.optional()});

export const transactionAleoTransaction = z.object({feeMicrocredits: z.string().optional(), feeOperation: transactionFeePublic.optional(), operations: z.array(transactionAleoOperation).optional()});

export const v2Transaction = z.object({name: z.string().optional(), type: v2TransactionTypeEnum.optional(), subType: v2TransactionSubTypeEnum.optional(), state: v2TransactionStateEnum.optional(), error: googlerpcStatus.optional(), direction: v2TransactionDirectionEnum.optional(), note: z.string().optional(), network: z.string().optional(), hash: z.string().optional(), blockNumber: z.string().optional(), signingSession: z.string().optional(), request: v2TransactionRequest.optional(), amlDetails: transactionAMLDetails.optional(), transfers: z.array(transactionTransfer).optional(), tokenAllowances: z.array(transactionTokenAllowance).optional(), designatedSigners: z.array(z.string()).optional(), evmTransaction: v2TransactionEVMTransaction.optional(), evmMessage: transactionEVMMessage.optional(), tronPersonalSign: v2TransactionTronPersonalSign.optional(), evmAccountDelegation: v2TransactionEVMAccountDelegation.optional(), tronTransaction: v2TransactionTronTransaction.optional(), btcTransaction: transactionBTCTransaction.optional(), btcPsbt: v2TransactionBTCPSBT.optional(), aptosTransaction: transactionAptosTransaction.optional(), suiTransaction: transactionSuiTransaction.optional(), suiSignPersonalMessage: v2TransactionSuiSignPersonalMessage.optional(), xrplTransaction: transactionXRPLTransaction.optional(), substrateTransaction: transactionSubstrateTransaction.optional(), tonTransaction: transactionTonTransaction.optional(), tonSignData: v2TransactionTonSignData.optional(), tonProof: v2TransactionTonProof.optional(), solanaSignMessage: v2TransactionSolanaSignMessage.optional(), solanaTransaction: v2TransactionSolanaTransaction.optional(), thetaTransaction: transactionThetaTransaction.optional(), stellarTransaction: v2TransactionStellarTransaction.optional(), aleoTransaction: transactionAleoTransaction.optional(), createTime: z.string().optional(), mineTime: z.string().optional(), confirmTime: z.string().optional(), expireTime: z.string().optional(), spam: z.boolean().optional(), annotations: z.record(z.string(), z.string()).optional(), replacementTransaction: z.string().optional()});

export const v2AssetTypeEnum = z.enum(["NATIVE_CURRENCY", "TOKEN"]);

export const assetTokenInfoStandardEnum = z.enum(["ERC20", "ERC721", "ERC1155", "TRC20", "SPL_TOKEN", "SPL_TOKEN_2022", "ICS20", "JETTON", "TIP20", "ERC7984"]);

export const v2CantonTokenDetails = z.object({instrumentId: z.string().optional(), instrumentAdmin: z.string().optional(), supportsTransferPreapproval: z.boolean().optional()});

export const v2SuiTokenDetails = z.object({gasless: z.boolean().optional()});

export const v2EVMTokenDetails = z.object({zamaConfidentialTokenPair: z.string().optional()});

export const v2AssetTokenInfo = z.object({contractAddress: z.string().optional(), standard: assetTokenInfoStandardEnum.optional(), denom: z.string().optional(), cantonTokenDetails: v2CantonTokenDetails.optional(), tip20Currency: z.string().optional(), suiTokenDetails: v2SuiTokenDetails.optional(), evmTokenDetails: v2EVMTokenDetails.optional()});

export const v2Asset = z.object({name: z.string().optional(), displayName: z.string().optional(), network: z.string().optional(), type: v2AssetTypeEnum.optional(), symbol: z.string().optional(), decimals: z.number().int().optional(), convertedValue: v2ConvertedValue.optional(), tokenInfo: v2AssetTokenInfo.optional()});

export const v2WalletEVMDetails = z.object({address: z.string().optional()});

export const walletTronDetails = z.object({address: z.string().optional()});

export const v2WalletTonDetails = z.object({address: z.string().optional()});

export const walletSolanaDetails = z.object({address: z.string().optional()});

export const v2WalletStellarDetails = z.object({address: z.string().optional()});

export const walletXRPLDetails = z.object({signingPubKey: z.string().optional()});

export const bTCDetailsAddressFormat = z.enum(["P2PKH", "P2WPKH", "P2TR"]);

export const walletCreateParamsBTCDetailsBTCNetworkDetails = z.object({network: z.string(), format: bTCDetailsAddressFormat});

export const v2WalletCreateParamsBTCDetails = z.object({btcNetworkDetails: z.array(walletCreateParamsBTCDetailsBTCNetworkDetails).optional()});

export const v2WalletCreateParams = z.object({walletGroups: z.array(z.string()).optional(), btcDetails: v2WalletCreateParamsBTCDetails.optional()});

export const v2WalletBTCDetailsBTCNetworkDetails = z.object({network: z.string().optional(), mainAddress: z.string().optional(), xpub: z.string().optional(), format: bTCDetailsAddressFormat.optional()});

export const v2WalletBTCDetails = z.object({btcNetworkDetails: z.array(v2WalletBTCDetailsBTCNetworkDetails).optional()});

export const v2Wallet = z.object({name: z.string().optional(), displayName: z.string(), external: z.boolean().optional(), archived: z.boolean().optional(), convertedValue: v2ConvertedValue.optional(), incompleteValue: z.boolean().optional(), hasFrozenAssets: z.boolean().optional(), networks: z.array(z.string()), evmDetails: v2WalletEVMDetails.optional(), tronDetails: walletTronDetails.optional(), tonDetails: v2WalletTonDetails.optional(), solanaDetails: walletSolanaDetails.optional(), stellarDetails: v2WalletStellarDetails.optional(), xrplDetails: walletXRPLDetails.optional(), createParams: v2WalletCreateParams.optional(), btcDetails: v2WalletBTCDetails.optional()});

export const walletAddressFormat = z.enum(["BITCOIN_P2PKH", "BITCOIN_P2WPKH", "EVM", "TRON_BASE58", "BASE58", "TON_NON_BOUNCEABLE", "SUBSTRATE_58", "BITCOIN_P2TR"]);

export const v2WalletAddressType = z.enum(["MAIN", "DEPOSIT", "CHANGE"]);

export const v2WalletAddressCreateParamsBTCDetails = z.object({format: bTCDetailsAddressFormat});

export const v2WalletAddressCreateParams = z.object({btcDetails: v2WalletAddressCreateParamsBTCDetails.optional()});

export const v2WalletAddress = z.object({name: z.string().optional(), displayName: z.string().optional(), network: z.string(), address: z.string().optional(), format: walletAddressFormat.optional(), key: z.string().optional(), keyDerivationPath: z.array(z.string()).optional(), type: v2WalletAddressType.optional(), note: z.string().optional(), createParams: v2WalletAddressCreateParams.optional()});

export const apiUserTypeEnum = z.enum(["USER_ACCOUNT", "SERVICE_ACCOUNT"]);

export const apiUserRoleEnum = z.enum(["ADMIN", "SIGNER", "VIEWER", "OWNER", "NON_SIGNING_OPERATOR", "NON_SIGNING_ADMIN"]);

export const apiUserStatusEnum = z.enum(["PENDING", "ACTIVE"]);

export const apiv2VaultContext = z.object({vaultId: z.string().optional(), role: apiUserRoleEnum.optional(), status: apiUserStatusEnum.optional()});

export const v2User = z.object({name: z.string().optional(), fullname: z.string().optional(), email: z.string(), pictureUri: z.string().optional(), type: apiUserTypeEnum.optional(), vaultContext: apiv2VaultContext.optional()});

export const walletconnectSessionPeer = z.object({uri: z.string().optional(), name: z.string().optional(), description: z.string().optional(), icon: z.string().optional()});

export const verificationContextValidationEnum = z.enum(["UNKNOWN", "VALID", "INVALID"]);

export const walletconnectSessionVerificationContext = z.object({origin: z.string().optional(), validation: verificationContextValidationEnum.optional(), verifyUrl: z.string().optional()});

export const v2WalletconnectSession = z.object({name: z.string().optional(), initiator: z.string().optional(), peer: walletconnectSessionPeer.optional(), network: z.string().optional(), verificationContext: walletconnectSessionVerificationContext.optional()});

export const v2AddressBookEntry = z.object({name: z.string().optional(), address: z.string(), displayName: z.string(), network: z.string().optional(), note: z.string().optional(), createTime: z.string().optional(), tracked: z.boolean().optional(), associatedExternalWallet: z.string().optional(), creator: z.string().optional(), signed: z.boolean().optional()});

export const v2VerificationStatusEnum = z.enum(["VERIFIED", "PENDING"]);

export const v2SignedDataTypeEnum = z.enum(["JSON_V1", "LEGACY", "MERKLE_ROOT", "COINCOVER_V1", "STATION70_V1", "COINCOVER_V2"]);

export const v2SignedData = z.object({type: v2SignedDataTypeEnum.optional(), data: z.string().optional(), signature: z.string().optional()});

export const v2LinkAddress = z.object({address: z.string().optional(), network: z.string().optional(), connectionId: z.string().optional(), verificationStatus: v2VerificationStatusEnum.optional(), signature: v2SignedData.optional(), createTime: z.string().optional(), updateTime: z.string().optional(), archiveTime: z.string().optional(), connectionDisplayName: z.string().optional(), targetProfileDisplayName: z.string().optional(), name: z.string().optional()});

export const v2ReferencedResource = z.object({asset: v2Asset.optional(), wallet: v2Wallet.optional(), walletAddress: v2WalletAddress.optional(), user: v2User.optional(), walletconnectSession: v2WalletconnectSession.optional(), addressBookEntry: v2AddressBookEntry.optional(), transaction: v2Transaction.optional(), linkAddress: v2LinkAddress.optional()});

export const v2NetworkAddressInfo = z.object({wallet: z.string().optional(), walletAddress: z.string().optional(), addressBookEntry: z.string().optional(), linkAddress: z.string().optional()});

export const v2InitiateTransactionResponse = z.object({transaction: v2Transaction.optional(), referencedResources: z.record(z.string(), v2ReferencedResource).optional(), referencedAddressesInfo: z.record(z.string(), v2NetworkAddressInfo).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
};

/**
 * InitiateTransaction
 * 
 * POST /v2/vaults/{vault_id}/transactions:initiate
 */
export const createApiV2VaultsVaultIdTransactionsInitiate = async (args: CreateApiV2VaultsVaultIdTransactionsInitiateArgs, options?: CreateApiV2VaultsVaultIdTransactionsInitiateOptions) => {
const {baseUrl = "https://api.utila.io", fetch: fetchFn = fetch, bearerAuth} = options ?? {}

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

if (bearerAuth !== undefined) headers.set('authorization', `Bearer ${bearerAuth}`)

const url = `${baseUrl.replace(/\/+$/, '')}/v2/vaults/${encodeURIComponent(String(args.vault_id))}/transactions:initiate${query.size > 0 ? `?${query}` : ''}`

const res = await fetchFn(url, {method: "POST", headers, body: JSON.stringify(args.body)})

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

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