import {z} from 'zod'

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

export type CoreIntentType = 'v0_NotarizeData' | 'v0_ExecuteExtension' | 'v0_CreateDomain' | 'v0_UpdateDomain' | 'v0_UpdateDomainPermissions' | 'v0_UnlockDomain' | 'v0_LockDomain' | 'v0_CreateUser' | 'v0_UpdateUser' | 'v0_UnlockUser' | 'v0_LockUser' | 'v0_CreatePolicy' | 'v0_UpdatePolicy' | 'v0_UnlockPolicy' | 'v0_LockPolicy' | 'v0_CreateVault' | 'v0_UpdateVault' | 'v0_UnlockVault' | 'v0_LockVault' | 'v0_RewrapVaultKeyMaterial' | 'v0_UnlockTicker' | 'v0_LockTicker' | 'v0_CreateEndpoint' | 'v0_UpdateEndpoint' | 'v0_UnlockEndpoint' | 'v0_LockEndpoint' | 'v0_CreateAccount' | 'v0_MigrateSilo3AccountBatch' | 'v0_UpdateAccount' | 'v0_UnlockAccount' | 'v0_LockAccount' | 'v0_AddAccountLedgers' | 'v0_CreateTransactionOrder' | 'v0_ReleaseQuarantinedTransfers' | 'v0_CreateTicker' | 'v0_AttemptTransactionOrderCancellation' | 'v0_ValidateTickers' | 'v0_UpdateTicker' | 'v0_CreateTransferOrder' | 'v0_SignManifest' | 'v0_SetSystemProperty' | 'v0_CreateLedger' | 'v0_UpdateLedger' | 'v0_AddTrustedPublicKeysForMigration' | 'v0_RegisterTrustedPublicKey' | 'v0_CreateBackup' | 'v0_AcknowledgeBackup';

export type CoreIntentStatus = 'Open' | 'Approved' | 'Executed' | 'Failed' | 'Expired' | 'Rejected' | 'Executing';

export type GetApiV1DomainsDomainIdIntentsArgs = {domainId: string, limit?: number | undefined, startingAfter?: string | undefined, sortBy?: ('id' | 'state.status' | 'details.expiryAt' | 'details.metadata.createdAt' | 'state.lastModifiedAt') | undefined, sortOrder?: CoreSortOrder | undefined, 'details.payload.type'?: Array<CoreIntentType> | undefined, 'details.author.domainId'?: string | undefined, 'details.author.id'?: string | undefined, 'details.author.subject'?: string | undefined, 'details.targetDomainId'?: Array<string> | undefined, 'details.metadata.description'?: string | undefined, 'details.metadata.customProperties'?: Array<string> | undefined, 'state.status'?: Array<CoreIntentStatus> | undefined, entityId?: string | undefined, revision?: number | undefined, policyId?: string | undefined};

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

export const coreV0AcknowledgeBackup = z.object({backupId: z.string(), type: z.literal("v0_AcknowledgeBackup")});

export const coreEntityIdAndRevision = z.object({id: z.string(), revision: z.number().int().gte(1)});

export const coreV0AddAccountLedgers = z.object({reference: coreEntityIdAndRevision, ledgerIds: z.array(z.string().min(1).max(100)).optional(), type: z.literal("v0_AddAccountLedgers")});

export const coreV0AddTrustedPublicKeysForMigration = z.object({newCollectionSigningPublicKey: z.string(), newMessageSigningPublicKey: z.string(), newApiSigningPublicKey: z.string(), newKeyMaterial: z.string().min(1).max(5000), currentCollectionSigningPublicKey: z.string(), currentCollectionSigningPublicKeySignature: z.string(), type: z.literal("v0_AddTrustedPublicKeysForMigration")});

export const coreV0AttemptTransactionOrderCancellation = z.object({targetTransactionOrderId: z.string(), replacementTransactionOrderId: z.string(), reason: z.string().min(1).max(200), maximumFee: z.string().optional(), type: z.literal("v0_AttemptTransactionOrderCancellation")});

export const coreAccountKeyStrategy = z.enum(["VaultHard", "VaultSoft", "Random"]);

export const coreV0CreateAccountProviderDetailsPayload = z.object({vaultId: z.string(), keyStrategy: coreAccountKeyStrategy, type: z.literal("Vault")});

export const coreIntentLockStatus = z.enum(["Unlocked", "Locked"]);

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

export const coreV0CreateAccount = z.object({id: z.string(), alias: z.string().min(1).max(75), providerDetails: coreV0CreateAccountProviderDetailsPayload, ledgerId: z.string().min(1).max(100).optional(), ledgerIds: z.array(z.string().min(1).max(100)).optional(), lock: coreIntentLockStatus, description: z.string().max(250).optional(), customProperties: coreStringsMap, type: z.literal("v0_CreateAccount")});

export const coreVaultBackupParametersVaultHsm = z.object({vaultId: z.string(), type: z.literal("VaultHsm")});

export const coreVaultBackupParametersVaultMpc = z.object({vaultId: z.string(), type: z.literal("VaultMpc")});

export const coreVaultBackupParameters = z.discriminatedUnion("type", [coreVaultBackupParametersVaultHsm, coreVaultBackupParametersVaultMpc]);

export const coreV0CreateBackup = z.object({id: z.string(), parameters: coreVaultBackupParameters, description: z.string().max(250).optional(), customProperties: coreStringsMap, type: z.literal("v0_CreateBackup")});

export const coreGoverningStrategy = z.enum(["ConsiderDescendants", "CoerceDescendants"]);

export const coreReadAccess = z.object({domains: z.array(z.string().min(1).max(50)), users: z.array(z.string().min(1).max(50)), endpoints: z.array(z.string().min(1).max(50)), policies: z.array(z.string().min(1).max(50)), accounts: z.array(z.string().min(1).max(50)), transactions: z.array(z.string().min(1).max(50)), requests: z.array(z.string().min(1).max(50)), events: z.array(z.string().min(1).max(50))});

export const corePermissions = z.object({readAccess: coreReadAccess});

export const coreLoginId = z.object({id: z.string().min(1).max(500), providerId: z.string().min(1).max(100)});

export const coreCreateDomainGenesisUser = z.object({id: z.string(), alias: z.string().min(1).max(75), publicKey: z.string(), roles: z.array(z.string().min(1).max(50)), lock: coreIntentLockStatus, description: z.string().max(250).optional(), customProperties: coreStringsMap, loginIds: z.array(coreLoginId).optional()});

export const coreIntentType = z.enum(["v0_NotarizeData", "v0_ExecuteExtension", "v0_CreateDomain", "v0_UpdateDomain", "v0_UpdateDomainPermissions", "v0_UnlockDomain", "v0_LockDomain", "v0_CreateUser", "v0_UpdateUser", "v0_UnlockUser", "v0_LockUser", "v0_CreatePolicy", "v0_UpdatePolicy", "v0_UnlockPolicy", "v0_LockPolicy", "v0_CreateVault", "v0_UpdateVault", "v0_UnlockVault", "v0_LockVault", "v0_RewrapVaultKeyMaterial", "v0_UnlockTicker", "v0_LockTicker", "v0_CreateEndpoint", "v0_UpdateEndpoint", "v0_UnlockEndpoint", "v0_LockEndpoint", "v0_CreateAccount", "v0_MigrateSilo3AccountBatch", "v0_UpdateAccount", "v0_UnlockAccount", "v0_LockAccount", "v0_AddAccountLedgers", "v0_CreateTransactionOrder", "v0_ReleaseQuarantinedTransfers", "v0_CreateTicker", "v0_AttemptTransactionOrderCancellation", "v0_ValidateTickers", "v0_UpdateTicker", "v0_CreateTransferOrder", "v0_SignManifest", "v0_SetSystemProperty", "v0_CreateLedger", "v0_UpdateLedger", "v0_AddTrustedPublicKeysForMigration", "v0_RegisterTrustedPublicKey", "v0_CreateBackup", "v0_AcknowledgeBackup"]);

export const corePolicyScope = z.enum(["Self", "Descendants", "SelfAndDescendants"]);

export const coreScriptingEngine = z.literal("Javascript_v0");

export const corePolicyConditionAnd = z.object({left: z.lazy(() => corePolicyCondition), right: z.lazy(() => corePolicyCondition), type: z.literal("And")});

export const corePolicyConditionExpression = z.object({expression: z.string().min(1).max(10000), type: z.literal("Expression")});

export const corePolicyConditionOr = z.object({left: z.lazy(() => corePolicyCondition), right: z.lazy(() => corePolicyCondition), type: z.literal("Or")});

export const corePolicyCondition: z.ZodType<CorePolicyCondition> = z.discriminatedUnion("type", [corePolicyConditionAnd, corePolicyConditionExpression, corePolicyConditionOr]);

export const coreWorkflowConditionAnd = z.object({left: z.lazy(() => coreWorkflowCondition), right: z.lazy(() => coreWorkflowCondition), type: z.literal("And")});

export const coreWorkflowConditionOr = z.object({left: z.lazy(() => coreWorkflowCondition), right: z.lazy(() => coreWorkflowCondition), type: z.literal("Or")});

export const coreWorkflowConditionRoleQuorum = z.object({role: z.string().min(1).max(50), quorum: z.number().int().gte(1), type: z.literal("RoleQuorum")});

export const coreWorkflowCondition: z.ZodType<CoreWorkflowCondition> = z.discriminatedUnion("type", [coreWorkflowConditionAnd, coreWorkflowConditionOr, coreWorkflowConditionRoleQuorum]);

export const coreIntentOrigin = z.enum(["UserSigned", "SystemSigned"]);

export const coreCreateDomainGenesisPolicy = z.object({id: z.string(), alias: z.string().min(1).max(75), rank: z.number().int().gte(0).lte(1000), intentTypes: z.array(coreIntentType).optional(), scope: corePolicyScope, scriptingEngine: coreScriptingEngine, condition: corePolicyCondition.optional(), workflow: z.array(coreWorkflowCondition).optional(), lock: coreIntentLockStatus, description: z.string().max(250).optional(), customProperties: coreStringsMap, intentOrigin: coreIntentOrigin.optional()});

export const coreV0CreateDomain = z.object({id: z.string(), alias: z.string().min(1).max(75), lock: coreIntentLockStatus, governingStrategy: coreGoverningStrategy.optional(), permissions: corePermissions, description: z.string().max(250).optional(), customProperties: coreStringsMap, users: z.array(coreCreateDomainGenesisUser), policies: z.array(coreCreateDomainGenesisPolicy), childrenDomainIds: z.array(z.string()).optional(), type: z.literal("v0_CreateDomain")});

export const coreEndpointLedgerParameters = z.object({ABI: z.string().optional(), type: z.literal("Ethereum")});

export const coreV0CreateEndpoint = z.object({id: z.string(), address: z.string().min(1).max(512), trustScore: z.number().int().gte(0).lte(100), ledgerId: z.string().min(1).max(100), parameters: coreEndpointLedgerParameters.optional(), alias: z.string().min(1).max(75), lock: coreIntentLockStatus, description: z.string().max(250).optional(), customProperties: coreStringsMap, type: z.literal("v0_CreateEndpoint")});

export const coreLedgerParametersAlgorand = z.object({genesisId: z.string().max(50), genesisHash: z.string().min(44).max(44), nativeTickerSymbol: z.string().min(1).max(100), nativeTickerName: z.string().min(1).max(100), nativeTickerDecimals: z.number().int(), type: z.literal("Algorand")});

export const coreBitcoinLikeVaultLedgerIdentifier = z.enum(["btc", "ltc", "bch", "doge", "dash"]);

export const coreNetwork = z.enum(["mainnet", "testnet", "regtest"]);

export const coreLedgerParametersBitcoin = z.object({supportsSegWit: z.boolean(), vaultLedgerIdentifier: coreBitcoinLikeVaultLedgerIdentifier, network: coreNetwork, tickerSymbol: z.string().min(1).max(100), tickerName: z.string().min(1).max(100), dustLimit: z.string(), type: z.literal("Bitcoin")});

export const coreLedgerParametersCardano = z.object({nativeTickerSymbol: z.string().min(1).max(100), nativeTickerName: z.string().min(1).max(100), testnetMagic: z.number().int().gte(0).lte(4294967295).optional(), type: z.literal("Cardano")});

export const coreEthereumLikeVaultLedgerIdentifier = z.enum(["eth", "etc"]);

export const coreLedgerParametersEthereum = z.object({chainId: z.number().int(), vaultLedgerIdentifier: coreEthereumLikeVaultLedgerIdentifier, nativeTickerSymbol: z.string().min(1).max(100), nativeTickerName: z.string().min(1).max(100), supportsEIP1559: z.boolean(), type: z.literal("Ethereum")});

export const coreLedgerParametersHedera = z.object({nativeTickerSymbol: z.string().min(1).max(100), nativeTickerName: z.string().min(1).max(100), type: z.literal("Hedera")});

export const coreLedgerParametersSolana = z.object({nativeTickerSymbol: z.string().min(1).max(100), nativeTickerName: z.string().min(1).max(100), lamportsPerSignature: z.string(), type: z.literal("Solana")});

export const coreLedgerParametersStellar = z.object({nativeTickerSymbol: z.string().min(1).max(100), nativeTickerName: z.string().min(1).max(100), networkPassphrase: z.string().min(12).max(100), type: z.literal("Stellar")});

export const coreSubstrateFeeParameters = z.object({baseExtrinsic: z.number().int().gte(0), readWeight: z.number().int().gte(0), writeWeight: z.number().int().gte(0), transactionByteFee: z.string(), weightToFeePolynomial: z.array(z.string()), type: z.literal("TransactionPayment")});

export const coreSubstrateMethodFeeParameters = z.object({base: z.number().int().gte(0), reads: z.number().int().gte(0), writes: z.number().int().gte(0), type: z.literal("MethodWeight")});

export const coreSubstrateMethodInfo = z.object({name: z.string(), methodId: z.number().int(), feeParameters: coreSubstrateMethodFeeParameters});

export const coreSubstratePalletInfo = z.object({name: z.string(), moduleId: z.number().int(), methods: z.array(coreSubstrateMethodInfo)});

export const coreSubstrateChainType = z.enum(["RelayChain", "AssetHub"]);

export const coreSubstrateRuntimeInfo = z.object({transactionVersion: z.number().int(), feeParameters: coreSubstrateFeeParameters, pallets: z.array(coreSubstratePalletInfo), chainType: coreSubstrateChainType.optional()});

export const coreLedgerParametersSubstrate = z.object({genesisHash: z.string(), addressPrefix: z.number().int().gte(0).lte(16383), nativeTickerSymbol: z.string().min(1).max(100), nativeTickerName: z.string().min(1).max(100), nativeTickerDecimals: z.number().int(), supportedRuntimeVersions: z.array(coreSubstrateRuntimeInfo), type: z.literal("Substrate")});

export const coreLedgerParametersTezos = z.object({nativeTickerSymbol: z.string().min(1).max(100), nativeTickerName: z.string().min(1).max(100), chainId: z.string(), type: z.literal("Tezos")});

export const coreLedgerParametersTron = z.object({nativeTickerSymbol: z.string().min(1).max(100), nativeTickerName: z.string().min(1).max(100), type: z.literal("Tron")});

export const coreLedgerParametersXRPL = z.object({nativeTickerSymbol: z.string().min(1).max(100), nativeTickerName: z.string().min(1).max(100), networkId: z.number().int(), type: z.literal("XRPL")});

export const coreLedgerParameters = z.discriminatedUnion("type", [coreLedgerParametersAlgorand, coreLedgerParametersBitcoin, coreLedgerParametersCardano, coreLedgerParametersEthereum, coreLedgerParametersHedera, coreLedgerParametersSolana, coreLedgerParametersStellar, coreLedgerParametersSubstrate, coreLedgerParametersTezos, coreLedgerParametersTron, coreLedgerParametersXRPL]);

export const coreV0CreateLedger = z.object({id: z.string(), alias: z.string().min(1).max(200), parameters: coreLedgerParameters, description: z.string().max(250).optional(), customProperties: coreStringsMap, type: z.literal("v0_CreateLedger")});

export const coreV0CreatePolicy = z.object({id: z.string(), alias: z.string().min(1).max(75), rank: z.number().int().gte(0).lte(1000), intentTypes: z.array(coreIntentType).optional(), scope: corePolicyScope, scriptingEngine: coreScriptingEngine, condition: corePolicyCondition.optional(), workflow: z.array(coreWorkflowCondition).optional(), lock: coreIntentLockStatus, description: z.string().max(250).optional(), customProperties: coreStringsMap, intentOrigin: coreIntentOrigin.optional(), type: z.literal("v0_CreatePolicy")});

export const coreTickerKind = z.enum(["Native", "Contract", "Token"]);

export const coreAlgorandTickerProperties = z.object({type: z.literal("Native")});

export const coreTickerLedgerDetailsAlgorand = z.object({properties: coreAlgorandTickerProperties, type: z.literal("Algorand")});

export const coreBitcoinTickerProperties = z.object({type: z.literal("Native")});

export const coreTickerLedgerDetailsBitcoin = z.object({properties: coreBitcoinTickerProperties, type: z.literal("Bitcoin")});

export const coreCardanoTickerProperties = z.object({type: z.literal("Native")});

export const coreTickerLedgerDetailsCardano = z.object({properties: coreCardanoTickerProperties, type: z.literal("Cardano")});

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

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

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

export const coreEthereumTickerPropertiesNative = z.object({type: z.literal("Native")});

export const coreEthereumTickerProperties = z.discriminatedUnion("type", [coreEthereumTickerPropertiesERC1155, coreEthereumTickerPropertiesERC20, coreEthereumTickerPropertiesERC721, coreEthereumTickerPropertiesNative]);

export const coreTickerLedgerDetailsEthereum = z.object({properties: coreEthereumTickerProperties, type: z.literal("Ethereum")});

export const coreHederaTickerPropertiesFungibleToken = z.object({id: z.string().min(5).max(20), type: z.literal("FungibleToken")});

export const coreHederaTickerPropertiesNative = z.object({type: z.literal("Native")});

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

export const coreHederaTickerProperties = z.discriminatedUnion("type", [coreHederaTickerPropertiesFungibleToken, coreHederaTickerPropertiesNative, coreHederaTickerPropertiesNonFungibleToken]);

export const coreTickerLedgerDetailsHedera = z.object({properties: coreHederaTickerProperties, type: z.literal("Hedera")});

export const coreSolanaTickerPropertiesNative = z.object({type: z.literal("Native")});

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

export const coreSolanaTickerPropertiesToken = z.object({mint: z.string().min(1).max(512), tokenType: coreSolanaTokenType, type: z.literal("Token")});

export const coreSolanaTickerProperties = z.discriminatedUnion("type", [coreSolanaTickerPropertiesNative, coreSolanaTickerPropertiesToken]);

export const coreTickerLedgerDetailsSolana = z.object({properties: coreSolanaTickerProperties, type: z.literal("Solana")});

export const coreStellarTickerPropertiesNative = z.object({type: z.literal("Native")});

export const coreStellarTickerPropertiesToken = z.object({code: z.string().min(1).max(100), issuer: z.string().min(1).max(512), type: z.literal("Token")});

export const coreStellarTickerProperties = z.discriminatedUnion("type", [coreStellarTickerPropertiesNative, coreStellarTickerPropertiesToken]);

export const coreTickerLedgerDetailsStellar = z.object({properties: coreStellarTickerProperties, type: z.literal("Stellar")});

export const coreSubstrateTickerProperties = z.object({type: z.literal("Native")});

export const coreTickerLedgerDetailsSubstrate = z.object({properties: coreSubstrateTickerProperties, type: z.literal("Substrate")});

export const coreTezosTickerProperties = z.object({type: z.literal("Native")});

export const coreTickerLedgerDetailsTezos = z.object({properties: coreTezosTickerProperties, type: z.literal("Tezos")});

export const coreTronTickerPropertiesNative = z.object({type: z.literal("Native")});

export const coreTronTickerPropertiesTRC20 = z.object({contractAddress: z.string().min(1).max(512), type: z.literal("TRC20")});

export const coreTronTickerProperties = z.discriminatedUnion("type", [coreTronTickerPropertiesNative, coreTronTickerPropertiesTRC20]);

export const coreTickerLedgerDetailsTron = z.object({properties: coreTronTickerProperties, type: z.literal("Tron")});

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

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

export const coreXrplTickerPropertiesNative = z.object({type: z.literal("Native")});

export const coreXrplTickerProperties = z.discriminatedUnion("type", [coreXrplTickerPropertiesFungibleToken, coreXrplTickerPropertiesMultiPurposeToken, coreXrplTickerPropertiesNative]);

export const coreTickerLedgerDetailsXRPL = z.object({properties: coreXrplTickerProperties, type: z.literal("XRPL")});

export const coreTickerLedgerDetails = z.discriminatedUnion("type", [coreTickerLedgerDetailsAlgorand, coreTickerLedgerDetailsBitcoin, coreTickerLedgerDetailsCardano, coreTickerLedgerDetailsEthereum, coreTickerLedgerDetailsHedera, coreTickerLedgerDetailsSolana, coreTickerLedgerDetailsStellar, coreTickerLedgerDetailsSubstrate, coreTickerLedgerDetailsTezos, coreTickerLedgerDetailsTron, coreTickerLedgerDetailsXRPL]);

export const coreV0CreateTicker = z.object({ledgerId: z.string().min(1).max(100), kind: coreTickerKind, name: z.string().min(1).max(100), decimals: z.number().int().optional(), symbol: z.string().min(1).max(100).optional(), ledgerDetails: coreTickerLedgerDetails, type: z.literal("v0_CreateTicker")});

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 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 coreV0CreateTransactionOrder = z.object({id: z.string(), accountId: z.string(), ledgerId: z.string().min(1).max(100).optional(), parameters: coreTransactionOrderParameters, description: z.string().max(250).optional(), customProperties: coreStringsMap, type: z.literal("v0_CreateTransactionOrder")});

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

export const corePreferredAddressForChange = z.literal("PrimaryAddress");

export const coreV0CreateTransferOrder = z.object({id: z.string(), accountId: z.string(), tickerId: z.string(), outputs: z.array(coreCreateTransferOrderOutput), feeStrategy: coreFeePriority, maximumFee: z.string().optional(), preferredAddressForChange: corePreferredAddressForChange.optional(), description: z.string().max(250).optional(), customProperties: coreStringsMap, type: z.literal("v0_CreateTransferOrder")});

export const coreV0CreateUser = z.object({id: z.string(), alias: z.string().min(1).max(75), publicKey: z.string(), roles: z.array(z.string().min(1).max(50)), lock: coreIntentLockStatus, description: z.string().max(250).optional(), customProperties: coreStringsMap, loginIds: z.array(coreLoginId).optional(), type: z.literal("v0_CreateUser")});

export const coreVaultParametersHSM = z.object({type: z.literal("HSM")});

export const coreVaultParametersMPC = z.object({backupEncryptionKey: z.string().optional(), type: z.literal("MPC")});

export const coreVaultParameters = z.discriminatedUnion("type", [coreVaultParametersHSM, coreVaultParametersMPC]);

export const coreV0CreateVault = z.object({id: z.string(), alias: z.string().min(1).max(75), parameters: coreVaultParameters.optional(), publicKey: z.string(), lock: coreIntentLockStatus, description: z.string().max(250).optional(), customProperties: coreStringsMap, type: z.literal("v0_CreateVault")});

export const coreV0ExecuteExtension = z.object({payload: z.record(z.string(), z.object({})), type: z.literal("v0_ExecuteExtension")});

export const coreV0LockAccount = z.object({reference: coreEntityIdAndRevision, type: z.literal("v0_LockAccount")});

export const coreV0LockDomain = z.object({reference: coreEntityIdAndRevision, type: z.literal("v0_LockDomain")});

export const coreV0LockEndpoint = z.object({reference: coreEntityIdAndRevision, type: z.literal("v0_LockEndpoint")});

export const coreV0LockPolicy = z.object({reference: coreEntityIdAndRevision, type: z.literal("v0_LockPolicy")});

export const coreV0LockTicker = z.object({reference: coreEntityIdAndRevision, type: z.literal("v0_LockTicker")});

export const coreV0LockUser = z.object({reference: coreEntityIdAndRevision, type: z.literal("v0_LockUser")});

export const coreV0LockVault = z.object({reference: coreEntityIdAndRevision, type: z.literal("v0_LockVault")});

export const coreV3AccountToMigrate = z.object({id: z.string(), alias: z.string().min(1).max(75), description: z.string().max(250).optional(), ledgerId: z.string().min(1).max(100), lockStatus: coreIntentLockStatus, publicId: z.string(), customProperties: coreStringsMap});

export const coreV0MigrateSilo3AccountBatch = z.object({vaultId: z.string(), wasColdSilo: z.boolean(), wasTestSilo: z.boolean(), accounts: z.array(coreV3AccountToMigrate), type: z.literal("v0_MigrateSilo3AccountBatch")});

export const coreV0NotarizeData = z.object({data: z.string().min(1).max(10000), type: z.literal("v0_NotarizeData")});

export const coreTrustedPublicKeyPurpose = z.enum(["ApiSignatures", "TrustedCollectionSignatures", "MessagingSignatures", "SystemSignatures"]);

export const coreV0RegisterTrustedPublicKey = z.object({publicKey: z.string(), purpose: coreTrustedPublicKeyPurpose, type: z.literal("v0_RegisterTrustedPublicKey")});

export const coreV0ReleaseQuarantinedTransfers = z.object({accountId: z.string(), transferIds: z.array(z.string()), type: z.literal("v0_ReleaseQuarantinedTransfers")});

export const coreV0RewrapVaultKeyMaterial = z.object({vaultId: z.string(), description: z.string().max(250).optional(), customProperties: coreStringsMap, type: z.literal("v0_RewrapVaultKeyMaterial")});

export const coreNotarySystemSignedIntentsEnabledValue = z.object({enabled: z.boolean()});

export const coreReadWriteSystemPropertyKeyValueNotarySystemSignedIntentsEnabledProperty = z.object({value: coreNotarySystemSignedIntentsEnabledValue, type: z.literal("NotarySystemSignedIntentsEnabledProperty")});

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

export const coreStateReviewAuthorityValue = z.object({publicKey: coreAccountPublicKeyOnly});

export const coreReadWriteSystemPropertyKeyValueStateReviewAuthorityProperty = z.object({value: coreStateReviewAuthorityValue, type: z.literal("StateReviewAuthorityProperty")});

export const coreReadWriteSystemPropertyKeyValue = z.discriminatedUnion("type", [coreReadWriteSystemPropertyKeyValueNotarySystemSignedIntentsEnabledProperty, coreReadWriteSystemPropertyKeyValueStateReviewAuthorityProperty]);

export const coreV0SetSystemProperty = z.object({revision: z.number().int().gte(1).optional(), value: coreReadWriteSystemPropertyKeyValue, type: z.literal("v0_SetSystemProperty")});

export const coreManifestContentEIP191 = z.object({value: z.string().min(2).max(20002), type: z.literal("EIP-191")});

export const coreManifestContentJWTHeader = z.object({type: z.string().min(1).max(75).optional(), algorithm: z.string().min(1).max(75).optional(), additionalParameters: coreStringsMap.optional()});

export const coreManifestContentJWTPayload = z.object({issuer: z.string().min(1).max(75).optional(), subject: z.string().min(1).max(75).optional(), audience: z.string().min(1).max(75).optional(), expiration: z.number().int().optional(), notBefore: z.number().int().optional(), issuedAt: z.number().int().optional(), jwtId: z.string().min(1).max(75).optional(), additionalClaims: coreStringsMap.optional()});

export const coreManifestContentJWT = z.object({header: coreManifestContentJWTHeader, payload: coreManifestContentJWTPayload, type: z.literal("JWT")});

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

export const coreManifestContent = z.discriminatedUnion("type", [coreManifestContentEIP191, coreManifestContentJWT, coreManifestContentUnsafe]);

export const coreV0SignManifest = z.object({id: z.string(), accountId: z.string(), ledgerId: z.string().min(1).max(100).optional(), content: coreManifestContent, description: z.string().max(250).optional(), customProperties: coreStringsMap, type: z.literal("v0_SignManifest")});

export const coreV0UnlockAccount = z.object({reference: coreEntityIdAndRevision, type: z.literal("v0_UnlockAccount")});

export const coreV0UnlockDomain = z.object({reference: coreEntityIdAndRevision, type: z.literal("v0_UnlockDomain")});

export const coreV0UnlockEndpoint = z.object({reference: coreEntityIdAndRevision, type: z.literal("v0_UnlockEndpoint")});

export const coreV0UnlockPolicy = z.object({reference: coreEntityIdAndRevision, type: z.literal("v0_UnlockPolicy")});

export const coreV0UnlockTicker = z.object({reference: coreEntityIdAndRevision, type: z.literal("v0_UnlockTicker")});

export const coreV0UnlockUser = z.object({reference: coreEntityIdAndRevision, type: z.literal("v0_UnlockUser")});

export const coreV0UnlockVault = z.object({reference: coreEntityIdAndRevision, type: z.literal("v0_UnlockVault")});

export const coreV0UpdateAccount = z.object({reference: coreEntityIdAndRevision, alias: z.string().min(1).max(75), description: z.string().max(250).optional(), customProperties: coreStringsMap, type: z.literal("v0_UpdateAccount")});

export const coreV0UpdateDomain = z.object({reference: coreEntityIdAndRevision, alias: z.string().min(1).max(75), description: z.string().max(250).optional(), customProperties: coreStringsMap, type: z.literal("v0_UpdateDomain")});

export const coreV0UpdateDomainPermissions = z.object({reference: coreEntityIdAndRevision, permissions: corePermissions, type: z.literal("v0_UpdateDomainPermissions")});

export const coreV0UpdateEndpoint = z.object({reference: coreEntityIdAndRevision, address: z.string().min(1).max(512), trustScore: z.number().int().gte(0).lte(100), ledgerId: z.string().min(1).max(100).optional(), parameters: coreEndpointLedgerParameters.optional(), alias: z.string().min(1).max(75), description: z.string().max(250).optional(), customProperties: coreStringsMap, type: z.literal("v0_UpdateEndpoint")});

export const coreEntityStringIdAndRevision = z.object({id: z.string(), revision: z.number().int().gte(1)});

export const coreV0UpdateLedger = z.object({reference: coreEntityStringIdAndRevision, alias: z.string().min(1).max(200), parameters: coreLedgerParameters, description: z.string().max(250).optional(), customProperties: coreStringsMap, type: z.literal("v0_UpdateLedger")});

export const coreV0UpdatePolicy = z.object({reference: coreEntityIdAndRevision, alias: z.string().min(1).max(75), rank: z.number().int().gte(0).lte(1000), intentTypes: z.array(coreIntentType).optional(), scope: corePolicyScope, scriptingEngine: coreScriptingEngine, condition: corePolicyCondition.optional(), workflow: z.array(coreWorkflowCondition).optional(), description: z.string().max(250).optional(), customProperties: coreStringsMap, intentOrigin: coreIntentOrigin.optional(), type: z.literal("v0_UpdatePolicy")});

export const coreV0UpdateTicker = z.object({reference: coreEntityIdAndRevision, name: z.string().min(1).max(100), decimals: z.number().int().optional(), symbol: z.string().min(1).max(100).optional(), description: z.string().max(250).optional(), customProperties: coreStringsMap, type: z.literal("v0_UpdateTicker")});

export const coreV0UpdateUser = z.object({reference: coreEntityIdAndRevision, alias: z.string().min(1).max(75), roles: z.array(z.string().min(1).max(50)), description: z.string().max(250).optional(), customProperties: coreStringsMap, loginIds: z.array(coreLoginId).optional(), type: z.literal("v0_UpdateUser")});

export const coreV0UpdateVault = z.object({reference: coreEntityIdAndRevision, alias: z.string().min(1).max(75), parameters: coreVaultParameters.optional(), description: z.string().max(250).optional(), customProperties: coreStringsMap, type: z.literal("v0_UpdateVault")});

export const coreValidatedTickerKind = z.enum(["Native", "Contract", "Token"]);

export const coreTickerToValidate = z.object({id: z.string(), ledgerId: z.string().min(1).max(100), kind: coreValidatedTickerKind, name: z.string().min(1).max(100), decimals: z.number().int().optional(), symbol: z.string().min(1).max(100).optional(), ledgerDetails: coreTickerLedgerDetails, lock: coreIntentLockStatus, description: z.string().max(250).optional(), customProperties: coreStringsMap});

export const coreV0ValidateTickers = z.object({tickers: z.array(coreTickerToValidate), type: z.literal("v0_ValidateTickers")});

export const coreUserIntentPayload = z.discriminatedUnion("type", [coreV0AcknowledgeBackup, coreV0AddAccountLedgers, coreV0AddTrustedPublicKeysForMigration, coreV0AttemptTransactionOrderCancellation, coreV0CreateAccount, coreV0CreateBackup, coreV0CreateDomain, coreV0CreateEndpoint, coreV0CreateLedger, coreV0CreatePolicy, coreV0CreateTicker, coreV0CreateTransactionOrder, coreV0CreateTransferOrder, coreV0CreateUser, coreV0CreateVault, coreV0ExecuteExtension, coreV0LockAccount, coreV0LockDomain, coreV0LockEndpoint, coreV0LockPolicy, coreV0LockTicker, coreV0LockUser, coreV0LockVault, coreV0MigrateSilo3AccountBatch, coreV0NotarizeData, coreV0RegisterTrustedPublicKey, coreV0ReleaseQuarantinedTransfers, coreV0RewrapVaultKeyMaterial, coreV0SetSystemProperty, coreV0SignManifest, coreV0UnlockAccount, coreV0UnlockDomain, coreV0UnlockEndpoint, coreV0UnlockPolicy, coreV0UnlockTicker, coreV0UnlockUser, coreV0UnlockVault, coreV0UpdateAccount, coreV0UpdateDomain, coreV0UpdateDomainPermissions, coreV0UpdateEndpoint, coreV0UpdateLedger, coreV0UpdatePolicy, coreV0UpdateTicker, coreV0UpdateUser, coreV0UpdateVault, coreV0ValidateTickers]);

export const coreIntentAuthorService = z.object({subject: z.string().min(1).max(255)});

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

export const coreIntentAuthor = z.union([coreIntentAuthorService, coreIntentAuthorUser]);

export const coreIntentMetadata = z.object({description: z.string().max(250).optional(), createdAt: z.string(), customProperties: coreStringsMap});

export const coreIntentDetails = z.object({payload: coreUserIntentPayload, expiryAt: z.string(), author: coreIntentAuthor, targetDomainId: z.string(), metadata: coreIntentMetadata, proposalSignature: z.string(), signingKey: z.string().optional()});

export const coreIntentStatus = z.enum(["Open", "Approved", "Executed", "Failed", "Expired", "Rejected", "Executing"]);

export const coreUserOperationRejectionCode = z.enum(["AccountLocked", "AccountNotReady", "DecisionInvalid", "DomainLocked", "TickerLocked", "EndpointLocked", "EntityAlreadyCreated", "EntityRevisionMismatch", "EntityAlreadyUnlocked", "EntityAlreadyLocked", "LockStatusCannotBeChanged", "IntentAlreadyComplete", "IntentAlreadyExists", "IntentMissing", "InvalidParentDomain", "LedgerNotFound", "LedgerNotProvided", "InvalidLedgerParameters", "InvalidSystemPropertyParameters", "MustBeExecutedInCurrentDomain", "MustBeExecutedInParentDomain", "MustBeExecutedInRootDomain", "NoApplicablePoliciesForDomain", "NonUniquePoliciesById", "NonUniqueUsersByAlias", "NonUniqueValidatedTickersByLedgerDetails", "NonUniqueUsersById", "NonUniqueUsersByPublicKey", "NotApplicableForRootDomain", "PolicyRevisionMismatch", "PolicyScriptingExecutionFailed", "PolicyWorkflowFailed", "PublicKeyInvalid", "LoginIdAlreadyAssigned", "ProposerIntentSignatureMismatches", "RequestExpired", "IntentExpired", "StaleIntent", "RequestSubmitterLocked", "RequestSubmitterNotFound", "RequestSubmitterSignatureInvalid", "SystemSignatureInvalid", "SystemSigningKeyNotRegistered", "SystemSigningKeyMismatch", "SystemSignaturesKeyAlreadyRegistered", "SystemSignedProcessingDisabled", "UnsupportedAccountKeyStrategy", "VaultNotFound", "VaultLocked", "VaultHasRandomKeyAccounts", "VaultNotReady", "InvalidDestination", "InvalidTransactionOrderState", "InvalidTransactionOrderParameters", "InvalidTransferOrderParameters", "InvalidEndpointUpdateParameters", "InvalidEndpointCreateParameters", "InvalidManifestContent", "BatchTooLarge", "MigrateSilo3AccountBatchContainsDuplicateDerivationData", "MigrateSilo3AccountBatchContainsDuplicateAccountIds", "MigrateSilo3AccountAlreadyImported", "InvalidTickerLedgerDetails", "DuplicateTickerIdsToValidate", "DuplicateTickerLedgerDatasToValidate", "InvalidEntityId", "MissingLoginIds", "DuplicatedLoginIds", "FeatureFlagDisabled", "InvalidCreateAccountParameters", "InvalidAddAccountLedgersParameters", "CurrentPublicKeyNotMatching", "InvalidTrustedCollectionPublicKeySignature", "InvalidMigrationKeyMaterial", "InvalidEntityType", "DuplicatePublicKey", "UnsupportedTrustedPublicKeyPurpose", "TrustedPublicKeyAlreadyActive", "InvalidVaultParameters", "BackupNotReady", "BackupAcknowledgeDenied", "VaultOperationOnExternalAccount", "ExternalOperationOnVaultAccount", "ValidateTickersPostProcessingFailure"]);

export const coreIntentError = z.object({code: coreUserOperationRejectionCode, message: z.string().max(1000)});

export const coreWorkflowStepStatus = z.enum(["Open", "Approved", "Failed", "Rejected"]);

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

export const coreApprovalDecision = z.enum(["Approve", "Reject"]);

export const coreDecisionPayload = z.object({author: coreUserReference, authorRoles: z.array(z.string().min(1).max(50)), seenBySystemAt: z.string(), expiryAt: z.string().optional(), decision: coreApprovalDecision, approvalReason: z.string().max(5000).optional(), rejectionReason: z.string().min(1).max(5000).optional(), rawRequest: z.string().min(1).max(80000), signature: z.string()});

export const coreWorkflowStep = z.object({state: coreWorkflowStepStatus, decisions: z.array(coreDecisionPayload)});

export const corePolicyReference = z.object({id: z.string(), revision: z.number().int().gte(1), domainId: z.string()});

export const coreWorkflowProgress = z.object({stepProgress: z.array(coreWorkflowStep), policyReference: corePolicyReference});

export const coreIntentState = z.object({status: coreIntentStatus, lastModifiedAt: z.string().optional(), error: coreIntentError.optional(), progressPerPolicy: z.array(coreWorkflowProgress).optional()});

export const coreIntentEntity = z.object({id: z.string(), details: coreIntentDetails, state: coreIntentState});

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

export const coreTrustedIntentsCollection = z.object({items: z.array(coreTrustedIntent), 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 intents
 * 
 * GET /v1/domains/{domainId}/intents
 */
export const getApiV1DomainsDomainIdIntents = async (args: GetApiV1DomainsDomainIdIntentsArgs, options: GetApiV1DomainsDomainIdIntentsOptions) => {
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['details.payload.type'] ?? []) query.append("details.payload.type", String(item))
if (args['details.author.domainId'] != null) query.append("details.author.domainId", String(args['details.author.domainId']))
if (args['details.author.id'] != null) query.append("details.author.id", String(args['details.author.id']))
if (args['details.author.subject'] != null) query.append("details.author.subject", String(args['details.author.subject']))
for (const item of args['details.targetDomainId'] ?? []) query.append("details.targetDomainId", String(item))
if (args['details.metadata.description'] != null) query.append("details.metadata.description", String(args['details.metadata.description']))
for (const item of args['details.metadata.customProperties'] ?? []) query.append("details.metadata.customProperties", String(item))
for (const item of args['state.status'] ?? []) query.append("state.status", String(item))
if (args.entityId != null) query.append("entityId", String(args.entityId))
if (args.revision != null) query.append("revision", String(args.revision))
if (args.policyId != null) query.append("policyId", String(args.policyId))
if (httpAuth !== undefined) headers.set('authorization', `Bearer ${httpAuth}`)

const url = `${baseUrl.replace(/\/+$/, '')}/v1/domains/${encodeURIComponent(String(args.domainId))}/intents${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(coreTrustedIntentsCollection, await res.json())
};