@keetanetwork/anchor 0.0.7 → 0.0.9

package/services/asset-movement/common.js

@@ -0,0 +1,2776 @@
+import * as __typia_transform__assertGuard from "typia/lib/internal/_assertGuard.js";
+import * as __typia_transform__accessExpressionAsString from "typia/lib/internal/_accessExpressionAsString.js";
+import { lib as KeetaNetLib } from '@keetanetwork/keetanet-client';
+import * as CurrencyInfo from '@keetanetwork/currency-info';
+import { createAssert, createAssertEquals, createIs } from 'typia';
+;
+;
+// Example Asset Paths
+// paths: [
+// 	{
+// 		pair: [
+// 			{ location: 'chain:keeta:123', id: 'keeta_KT1EXmXoG7fV8b2c5rYkUu4j3t6b3v6v5X8m', rails: { common: [ 'KEETA_SEND' ] } },
+// 			{ location: 'chain:evm:100', id: '0xc0634090F2Fe6c6d75e61Be2b949464aBB498973', rails: { common: [ 'EVM_SEND' ], inbound: [ 'EVM_CALL' ] } }
+// 		]
+// 	},
+// 	{
+// 		pair: [
+// 			{ location: 'chain:keeta:123', id: 'keeta_USDCPUB', rails: ['KEETA_SEND'] },
+// 			{ location: 'bank-account:US', id: 'USD', rails: { common: ['ACH_SEND'], inbound: ['ACH_DEBIT'] } }
+// 		]
+// 	},
+// 	{
+// 		pair: [
+// 			{ location: 'bank-account:EU', id: 'EUR', rails: { inbound: [ 'WIRE_SEND' }] },
+// 			{ location: 'chain:keeta:123', id: 'keeta_EURCPUB', rails: { outbound: [ 'KEETA_SEND' ]} }
+// 		]
+// 	}
+// ];
+export function convertAssetLocationToString(input) {
+    if (typeof input === 'string') {
+        return (input);
+    }
+    if (input.type === 'chain') {
+        if (input.chain.type === 'keeta') {
+            return (`chain:keeta:${input.chain.networkId}`);
+        }
+        else if (input.chain.type === 'evm') {
+            return (`chain:evm:${input.chain.chainId}`);
+        }
+    }
+    else if (input.type === 'bank-account') {
+        throw (new Error('Cannot convert bank-account AssetLocation to string'));
+    }
+    throw (new Error(`Invalid AssetLocation type: ${JSON.stringify(input)}`));
+}
+export function toAssetLocationFromString(input) {
+    const parts = input.split(':');
+    if (parts.length === 3 && parts[0] === 'chain') {
+        const chainType = parts[1];
+        if (!parts[2] || typeof parts[2] !== 'string') {
+            throw (new Error('Invalid chain id in AssetLocation string'));
+        }
+        const chainId = BigInt(parts[2]);
+        return ({
+            type: 'chain',
+            chain: (() => {
+                if (chainType === 'keeta') {
+                    return ({
+                        type: 'keeta',
+                        networkId: chainId
+                    });
+                }
+                else if (chainType === 'evm') {
+                    return ({
+                        type: 'evm',
+                        chainId: chainId
+                    });
+                }
+                else {
+                    throw (new Error(`Invalid chain type in AssetLocation string: ${chainType}`));
+                }
+            })()
+        });
+    }
+    throw (new Error('unsupported AssetLocation string format'));
+}
+export function convertAssetLocationInputToCanonical(input) {
+    if (typeof input === 'string') {
+        return (input);
+    }
+    else if (typeof input === 'object' && input !== null) {
+        return (convertAssetLocationToString(input));
+    }
+    throw (new Error(`Invalid AssetLocationInput type: ${typeof input}`));
+}
+export function toAssetLocation(input) {
+    if (typeof input === 'string') {
+        return (toAssetLocationFromString(input));
+    }
+    else {
+        return (input);
+    }
+}
+export function convertAssetSearchInputToCanonical(input) {
+    if (input instanceof CurrencyInfo.Currency || CurrencyInfo.Currency.isCurrencyCode(input) || CurrencyInfo.Currency.isISOCurrencyNumber(input)) {
+        if (CurrencyInfo.Currency.isCurrencyCode(input)) {
+            return (input);
+        }
+        else if (CurrencyInfo.Currency.isISOCurrencyNumber(input)) {
+            input = new CurrencyInfo.Currency(input);
+        }
+        return (input.code);
+    }
+    else {
+        if (typeof input === 'string') {
+            return (input);
+        }
+        input.assertKeyType(KeetaNetLib.Account.AccountKeyAlgorithm.TOKEN);
+        return (input.publicKeyString.get());
+    }
+}
+export const assertKeetaSupportedAssets = (() => { const _io0 = input => "string" === typeof input.asset && (RegExp(/^keeta_am(.*)/).test(input.asset) || RegExp(/^keeta_an(.*)/).test(input.asset) || RegExp(/^keeta_ao(.*)/).test(input.asset) || RegExp(/^keeta_ap(.*)/).test(input.asset) || RegExp(/^tyblocks_am(.*)/).test(input.asset) || RegExp(/^tyblocks_an(.*)/).test(input.asset) || RegExp(/^tyblocks_ao(.*)/).test(input.asset) || RegExp(/^tyblocks_ap(.*)/).test(input.asset)) && (Array.isArray(input.paths) && input.paths.every(elem => "object" === typeof elem && null !== elem && _io1(elem))); const _io1 = input => Array.isArray(input.pair) && (input.pair.length === 2 && ("object" === typeof input.pair[0] && null !== input.pair[0] && _io2(input.pair[0])) && ("object" === typeof input.pair[1] && null !== input.pair[1] && _io2(input.pair[1]))) && (undefined === input.kycProviders || Array.isArray(input.kycProviders) && input.kycProviders.every(elem => "string" === typeof elem)); const _io2 = input => "object" === typeof input.rails && null !== input.rails && false === Array.isArray(input.rails) && _iu0(input.rails) && (undefined === input.location || "string" === typeof input.location && (RegExp(/^chain:keeta:[+-]?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/).test(input.location) || RegExp(/^chain:evm:[+-]?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/).test(input.location))) && "string" === typeof input.id; const _io3 = input => Array.isArray(input.inbound) && input.inbound.every(elem => "ACH_SEND" === elem || "ACH_DEBIT" === elem || "KEETA_SEND" === elem || "EVM_SEND" === elem || "EVM_CALL" === elem) && (undefined === input.outbound || Array.isArray(input.outbound) && input.outbound.every(elem => "ACH_SEND" === elem || "ACH_DEBIT" === elem || "KEETA_SEND" === elem || "EVM_SEND" === elem || "EVM_CALL" === elem)) && (undefined === input.common || Array.isArray(input.common) && input.common.every(elem => "ACH_SEND" === elem || "ACH_DEBIT" === elem || "KEETA_SEND" === elem || "EVM_SEND" === elem || "EVM_CALL" === elem)); const _io4 = input => (undefined === input.inbound || Array.isArray(input.inbound) && input.inbound.every(elem => "ACH_SEND" === elem || "ACH_DEBIT" === elem || "KEETA_SEND" === elem || "EVM_SEND" === elem || "EVM_CALL" === elem)) && (Array.isArray(input.outbound) && input.outbound.every(elem => "ACH_SEND" === elem || "ACH_DEBIT" === elem || "KEETA_SEND" === elem || "EVM_SEND" === elem || "EVM_CALL" === elem)) && (undefined === input.common || Array.isArray(input.common) && input.common.every(elem => "ACH_SEND" === elem || "ACH_DEBIT" === elem || "KEETA_SEND" === elem || "EVM_SEND" === elem || "EVM_CALL" === elem)); const _io5 = input => null !== input.inbound && undefined === input.inbound && (null !== input.outbound && undefined === input.outbound) && (undefined === input.common || Array.isArray(input.common) && input.common.every(elem => "ACH_SEND" === elem || "ACH_DEBIT" === elem || "KEETA_SEND" === elem || "EVM_SEND" === elem || "EVM_CALL" === elem)); const _iu0 = input => (() => {
+    if (_io5(input))
+        return _io5(input);
+    if (_io4(input))
+        return _io4(input);
+    if (_io3(input))
+        return _io3(input);
+    return false;
+})(); const _ao0 = (input, _path, _exceptionable = true) => ("string" === typeof input.asset && (RegExp(/^keeta_am(.*)/).test(input.asset) || RegExp(/^keeta_an(.*)/).test(input.asset) || RegExp(/^keeta_ao(.*)/).test(input.asset) || RegExp(/^keeta_ap(.*)/).test(input.asset) || RegExp(/^tyblocks_am(.*)/).test(input.asset) || RegExp(/^tyblocks_an(.*)/).test(input.asset) || RegExp(/^tyblocks_ao(.*)/).test(input.asset) || RegExp(/^tyblocks_ap(.*)/).test(input.asset)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".asset",
+    expected: "(`keeta_am${string}` | `keeta_an${string}` | `keeta_ao${string}` | `keeta_ap${string}` | `tyblocks_am${string}` | `tyblocks_an${string}` | `tyblocks_ao${string}` | `tyblocks_ap${string}`)",
+    value: input.asset
+}, _errorFactory)) && ((Array.isArray(input.paths) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".paths",
+    expected: "Array<AssetPath>",
+    value: input.paths
+}, _errorFactory)) && input.paths.every((elem, _index12) => ("object" === typeof elem && null !== elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".paths[" + _index12 + "]",
+    expected: "AssetPath",
+    value: elem
+}, _errorFactory)) && _ao1(elem, _path + ".paths[" + _index12 + "]", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".paths[" + _index12 + "]",
+    expected: "AssetPath",
+    value: elem
+}, _errorFactory)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".paths",
+    expected: "Array<AssetPath>",
+    value: input.paths
+}, _errorFactory)); const _ao1 = (input, _path, _exceptionable = true) => ((Array.isArray(input.pair) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".pair",
+    expected: "[AssetWithRails, AssetWithRails]",
+    value: input.pair
+}, _errorFactory)) && ((input.pair.length === 2 || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".pair",
+    expected: "[AssetWithRails, AssetWithRails]",
+    value: input.pair
+}, _errorFactory)) && (("object" === typeof input.pair[0] && null !== input.pair[0] || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".pair[0]",
+    expected: "AssetWithRails",
+    value: input.pair[0]
+}, _errorFactory)) && _ao2(input.pair[0], _path + ".pair[0]", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".pair[0]",
+    expected: "AssetWithRails",
+    value: input.pair[0]
+}, _errorFactory)) && (("object" === typeof input.pair[1] && null !== input.pair[1] || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".pair[1]",
+    expected: "AssetWithRails",
+    value: input.pair[1]
+}, _errorFactory)) && _ao2(input.pair[1], _path + ".pair[1]", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".pair[1]",
+    expected: "AssetWithRails",
+    value: input.pair[1]
+}, _errorFactory))) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".pair",
+    expected: "[AssetWithRails, AssetWithRails]",
+    value: input.pair
+}, _errorFactory)) && (undefined === input.kycProviders || (Array.isArray(input.kycProviders) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".kycProviders",
+    expected: "(Array<string> | undefined)",
+    value: input.kycProviders
+}, _errorFactory)) && input.kycProviders.every((elem, _index13) => "string" === typeof elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".kycProviders[" + _index13 + "]",
+    expected: "string",
+    value: elem
+}, _errorFactory)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".kycProviders",
+    expected: "(Array<string> | undefined)",
+    value: input.kycProviders
+}, _errorFactory)); const _ao2 = (input, _path, _exceptionable = true) => (("object" === typeof input.rails && null !== input.rails && false === Array.isArray(input.rails) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".rails",
+    expected: "({ inbound: Rail[]; outbound?: Rail[]; } & { common?: Rail[]; } | { inbound?: Rail[]; outbound: Rail[]; } & { common?: Rail[]; } | { inbound?: never; outbound?: never; } & { common?: Rail[]; })",
+    value: input.rails
+}, _errorFactory)) && _au0(input.rails, _path + ".rails", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".rails",
+    expected: "({ inbound: Rail[]; outbound?: Rail[]; } & { common?: Rail[]; } | { inbound?: Rail[]; outbound: Rail[]; } & { common?: Rail[]; } | { inbound?: never; outbound?: never; } & { common?: Rail[]; })",
+    value: input.rails
+}, _errorFactory)) && (undefined === input.location || "string" === typeof input.location && (RegExp(/^chain:keeta:[+-]?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/).test(input.location) || RegExp(/^chain:evm:[+-]?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/).test(input.location)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".location",
+    expected: "(`chain:evm:${bigint}` | `chain:keeta:${bigint}` | undefined)",
+    value: input.location
+}, _errorFactory)) && ("string" === typeof input.id || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".id",
+    expected: "string",
+    value: input.id
+}, _errorFactory)); const _ao3 = (input, _path, _exceptionable = true) => ((Array.isArray(input.inbound) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".inbound",
+    expected: "Array<Rail>",
+    value: input.inbound
+}, _errorFactory)) && input.inbound.every((elem, _index14) => "ACH_SEND" === elem || "ACH_DEBIT" === elem || "KEETA_SEND" === elem || "EVM_SEND" === elem || "EVM_CALL" === elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".inbound[" + _index14 + "]",
+    expected: "(\"ACH_DEBIT\" | \"ACH_SEND\" | \"EVM_CALL\" | \"EVM_SEND\" | \"KEETA_SEND\")",
+    value: elem
+}, _errorFactory)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".inbound",
+    expected: "Array<Rail>",
+    value: input.inbound
+}, _errorFactory)) && (undefined === input.outbound || (Array.isArray(input.outbound) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".outbound",
+    expected: "(Array<Rail> | undefined)",
+    value: input.outbound
+}, _errorFactory)) && input.outbound.every((elem, _index15) => "ACH_SEND" === elem || "ACH_DEBIT" === elem || "KEETA_SEND" === elem || "EVM_SEND" === elem || "EVM_CALL" === elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".outbound[" + _index15 + "]",
+    expected: "(\"ACH_DEBIT\" | \"ACH_SEND\" | \"EVM_CALL\" | \"EVM_SEND\" | \"KEETA_SEND\")",
+    value: elem
+}, _errorFactory)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".outbound",
+    expected: "(Array<Rail> | undefined)",
+    value: input.outbound
+}, _errorFactory)) && (undefined === input.common || (Array.isArray(input.common) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".common",
+    expected: "(Array<Rail> | undefined)",
+    value: input.common
+}, _errorFactory)) && input.common.every((elem, _index16) => "ACH_SEND" === elem || "ACH_DEBIT" === elem || "KEETA_SEND" === elem || "EVM_SEND" === elem || "EVM_CALL" === elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".common[" + _index16 + "]",
+    expected: "(\"ACH_DEBIT\" | \"ACH_SEND\" | \"EVM_CALL\" | \"EVM_SEND\" | \"KEETA_SEND\")",
+    value: elem
+}, _errorFactory)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".common",
+    expected: "(Array<Rail> | undefined)",
+    value: input.common
+}, _errorFactory)); const _ao4 = (input, _path, _exceptionable = true) => (undefined === input.inbound || (Array.isArray(input.inbound) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".inbound",
+    expected: "(Array<Rail> | undefined)",
+    value: input.inbound
+}, _errorFactory)) && input.inbound.every((elem, _index17) => "ACH_SEND" === elem || "ACH_DEBIT" === elem || "KEETA_SEND" === elem || "EVM_SEND" === elem || "EVM_CALL" === elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".inbound[" + _index17 + "]",
+    expected: "(\"ACH_DEBIT\" | \"ACH_SEND\" | \"EVM_CALL\" | \"EVM_SEND\" | \"KEETA_SEND\")",
+    value: elem
+}, _errorFactory)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".inbound",
+    expected: "(Array<Rail> | undefined)",
+    value: input.inbound
+}, _errorFactory)) && ((Array.isArray(input.outbound) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".outbound",
+    expected: "Array<Rail>",
+    value: input.outbound
+}, _errorFactory)) && input.outbound.every((elem, _index18) => "ACH_SEND" === elem || "ACH_DEBIT" === elem || "KEETA_SEND" === elem || "EVM_SEND" === elem || "EVM_CALL" === elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".outbound[" + _index18 + "]",
+    expected: "(\"ACH_DEBIT\" | \"ACH_SEND\" | \"EVM_CALL\" | \"EVM_SEND\" | \"KEETA_SEND\")",
+    value: elem
+}, _errorFactory)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".outbound",
+    expected: "Array<Rail>",
+    value: input.outbound
+}, _errorFactory)) && (undefined === input.common || (Array.isArray(input.common) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".common",
+    expected: "(Array<Rail> | undefined)",
+    value: input.common
+}, _errorFactory)) && input.common.every((elem, _index19) => "ACH_SEND" === elem || "ACH_DEBIT" === elem || "KEETA_SEND" === elem || "EVM_SEND" === elem || "EVM_CALL" === elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".common[" + _index19 + "]",
+    expected: "(\"ACH_DEBIT\" | \"ACH_SEND\" | \"EVM_CALL\" | \"EVM_SEND\" | \"KEETA_SEND\")",
+    value: elem
+}, _errorFactory)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".common",
+    expected: "(Array<Rail> | undefined)",
+    value: input.common
+}, _errorFactory)); const _ao5 = (input, _path, _exceptionable = true) => (null !== input.inbound || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".inbound",
+    expected: "undefined",
+    value: input.inbound
+}, _errorFactory)) && (undefined === input.inbound || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".inbound",
+    expected: "undefined",
+    value: input.inbound
+}, _errorFactory)) && ((null !== input.outbound || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".outbound",
+    expected: "undefined",
+    value: input.outbound
+}, _errorFactory)) && (undefined === input.outbound || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".outbound",
+    expected: "undefined",
+    value: input.outbound
+}, _errorFactory))) && (undefined === input.common || (Array.isArray(input.common) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".common",
+    expected: "(Array<Rail> | undefined)",
+    value: input.common
+}, _errorFactory)) && input.common.every((elem, _index20) => "ACH_SEND" === elem || "ACH_DEBIT" === elem || "KEETA_SEND" === elem || "EVM_SEND" === elem || "EVM_CALL" === elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".common[" + _index20 + "]",
+    expected: "(\"ACH_DEBIT\" | \"ACH_SEND\" | \"EVM_CALL\" | \"EVM_SEND\" | \"KEETA_SEND\")",
+    value: elem
+}, _errorFactory)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".common",
+    expected: "(Array<Rail> | undefined)",
+    value: input.common
+}, _errorFactory)); const _au0 = (input, _path, _exceptionable = true) => _ao5(input, _path, false && _exceptionable) || _ao4(input, _path, false && _exceptionable) || _ao3(input, _path, false && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path,
+    expected: "({ inbound?: never; outbound?: never; } & { common?: Rail[]; } | { inbound?: Rail[]; outbound: Rail[]; } & { common?: Rail[]; } | { inbound: Rail[]; outbound?: Rail[]; } & { common?: Rail[]; })",
+    value: input
+}, _errorFactory); const __is = input => Array.isArray(input) && input.every(elem => "object" === typeof elem && null !== elem && _io0(elem)); let _errorFactory; return (input, errorFactory) => {
+    if (false === __is(input)) {
+        _errorFactory = errorFactory;
+        ((input, _path, _exceptionable = true) => (Array.isArray(input) || __typia_transform__assertGuard._assertGuard(true, {
+            method: "createAssert",
+            path: _path + "",
+            expected: "Array<SupportedAssets>",
+            value: input
+        }, _errorFactory)) && input.every((elem, _index11) => ("object" === typeof elem && null !== elem || __typia_transform__assertGuard._assertGuard(true, {
+            method: "createAssert",
+            path: _path + "[" + _index11 + "]",
+            expected: "SupportedAssets",
+            value: elem
+        }, _errorFactory)) && _ao0(elem, _path + "[" + _index11 + "]", true) || __typia_transform__assertGuard._assertGuard(true, {
+            method: "createAssert",
+            path: _path + "[" + _index11 + "]",
+            expected: "SupportedAssets",
+            value: elem
+        }, _errorFactory)) || __typia_transform__assertGuard._assertGuard(true, {
+            method: "createAssert",
+            path: _path + "",
+            expected: "Array<SupportedAssets>",
+            value: input
+        }, _errorFactory))(input, "$input", true);
+    }
+    return input;
+}; })();
+export const assertKeetaAssetMovementAnchorCreatePersistentForwardingRequest = (() => { const _iv1 = new Set(["ALL", "AFN", "EUR", "DZD", "USD", "AOA", "XCD", "ARS", "AMD", "AWG", "AUD", "AZN", "BSD", "BHD", "BDT", "BBD", "BYN", "BZD", "XOF", "BMD", "INR", "BTN", "BOB", "BOV", "BAM", "BWP", "NOK", "BRL", "BND", "BGN", "BIF", "CVE", "KHR", "XAF", "CAD", "KYD", "CLP", "CLF", "CNY", "COP", "COU", "KMF", "CDF", "NZD", "CRC", "CUP", "CUC", "ANG", "CZK", "DKK", "DJF", "DOP", "EGP", "SVC", "ERN", "SZL", "ETB", "FKP", "FJD", "XPF", "GMD", "GEL", "GHS", "GIP", "GTQ", "GBP", "GNF", "GYD", "HTG", "HNL", "HKD", "HUF", "ISK", "IDR", "IRR", "IQD", "ILS", "JMD", "JPY", "JOD", "KZT", "KES", "KPW", "KRW", "KWD", "KGS", "LAK", "LBP", "LSL", "ZAR", "LRD", "LYD", "CHF", "MOP", "MKD", "MGA", "MWK", "MYR", "MVR", "MRU", "MUR", "MXN", "MXV", "MDL", "MNT", "MAD", "MZN", "MMK", "NAD", "NPR", "NIO", "NGN", "OMR", "PKR", "PAB", "PGK", "PYG", "PEN", "PHP", "PLN", "QAR", "RON", "RUB", "RWF", "SHP", "WST", "STN", "SAR", "RSD", "SCR", "SLL", "SLE", "SGD", "SBD", "SOS", "SSP", "LKR", "SDG", "SRD", "SEK", "CHE", "CHW", "SYP", "TWD", "TJS", "TZS", "THB", "TOP", "TTD", "TND", "TRY", "TMT", "UGX", "UAH", "AED", "USN", "UYU", "UYI", "UYW", "UZS", "VUV", "VES", "VED", "VND", "YER", "ZMW", "ZWL"]); const _iv2 = new Set(["971", "978", "8", "12", "840", "973", "951", "32", "51", "533", "36", "944", "44", "48", "50", "52", "933", "84", "952", "60", "356", "64", "68", "984", "977", "72", "578", "986", "96", "975", "108", "132", "116", "950", "124", "136", "152", "990", "156", "170", "970", "174", "976", "554", "188", "192", "931", "532", "203", "208", "262", "214", "818", "222", "232", "748", "230", "238", "242", "953", "270", "981", "936", "292", "320", "826", "324", "328", "332", "340", "344", "348", "352", "360", "364", "368", "376", "388", "392", "400", "398", "404", "408", "410", "414", "417", "418", "422", "426", "710", "430", "434", "756", "446", "807", "969", "454", "458", "462", "929", "480", "484", "979", "498", "496", "504", "943", "104", "516", "524", "558", "566", "512", "586", "590", "598", "600", "604", "608", "985", "634", "946", "643", "646", "654", "882", "930", "682", "941", "690", "694", "925", "702", "90", "706", "728", "144", "938", "968", "752", "947", "948", "760", "901", "972", "834", "764", "776", "780", "788", "949", "934", "800", "980", "784", "997", "858", "940", "927", "860", "548", "928", "926", "704", "886", "967", "932"]); const _av3 = new Set(["ALL", "AFN", "EUR", "DZD", "USD", "AOA", "XCD", "ARS", "AMD", "AWG", "AUD", "AZN", "BSD", "BHD", "BDT", "BBD", "BYN", "BZD", "XOF", "BMD", "INR", "BTN", "BOB", "BOV", "BAM", "BWP", "NOK", "BRL", "BND", "BGN", "BIF", "CVE", "KHR", "XAF", "CAD", "KYD", "CLP", "CLF", "CNY", "COP", "COU", "KMF", "CDF", "NZD", "CRC", "CUP", "CUC", "ANG", "CZK", "DKK", "DJF", "DOP", "EGP", "SVC", "ERN", "SZL", "ETB", "FKP", "FJD", "XPF", "GMD", "GEL", "GHS", "GIP", "GTQ", "GBP", "GNF", "GYD", "HTG", "HNL", "HKD", "HUF", "ISK", "IDR", "IRR", "IQD", "ILS", "JMD", "JPY", "JOD", "KZT", "KES", "KPW", "KRW", "KWD", "KGS", "LAK", "LBP", "LSL", "ZAR", "LRD", "LYD", "CHF", "MOP", "MKD", "MGA", "MWK", "MYR", "MVR", "MRU", "MUR", "MXN", "MXV", "MDL", "MNT", "MAD", "MZN", "MMK", "NAD", "NPR", "NIO", "NGN", "OMR", "PKR", "PAB", "PGK", "PYG", "PEN", "PHP", "PLN", "QAR", "RON", "RUB", "RWF", "SHP", "WST", "STN", "SAR", "RSD", "SCR", "SLL", "SLE", "SGD", "SBD", "SOS", "SSP", "LKR", "SDG", "SRD", "SEK", "CHE", "CHW", "SYP", "TWD", "TJS", "TZS", "THB", "TOP", "TTD", "TND", "TRY", "TMT", "UGX", "UAH", "AED", "USN", "UYU", "UYI", "UYW", "UZS", "VUV", "VES", "VED", "VND", "YER", "ZMW", "ZWL"]); const _av4 = new Set(["971", "978", "8", "12", "840", "973", "951", "32", "51", "533", "36", "944", "44", "48", "50", "52", "933", "84", "952", "60", "356", "64", "68", "984", "977", "72", "578", "986", "96", "975", "108", "132", "116", "950", "124", "136", "152", "990", "156", "170", "970", "174", "976", "554", "188", "192", "931", "532", "203", "208", "262", "214", "818", "222", "232", "748", "230", "238", "242", "953", "270", "981", "936", "292", "320", "826", "324", "328", "332", "340", "344", "348", "352", "360", "364", "368", "376", "388", "392", "400", "398", "404", "408", "410", "414", "417", "418", "422", "426", "710", "430", "434", "756", "446", "807", "969", "454", "458", "462", "929", "480", "484", "979", "498", "496", "504", "943", "104", "516", "524", "558", "566", "512", "586", "590", "598", "600", "604", "608", "985", "634", "946", "643", "646", "654", "882", "930", "682", "941", "690", "694", "925", "702", "90", "706", "728", "144", "938", "968", "752", "947", "948", "760", "901", "972", "834", "764", "776", "780", "788", "949", "934", "800", "980", "784", "997", "858", "940", "927", "860", "548", "928", "926", "704", "886", "967", "932"]); const _io0 = input => null !== input.asset && undefined !== input.asset && ("string" === typeof input.asset && (RegExp(/^keeta_am(.*)/).test(input.asset) || RegExp(/^keeta_an(.*)/).test(input.asset) || RegExp(/^keeta_ao(.*)/).test(input.asset) || RegExp(/^keeta_ap(.*)/).test(input.asset) || RegExp(/^tyblocks_am(.*)/).test(input.asset) || RegExp(/^tyblocks_an(.*)/).test(input.asset) || RegExp(/^tyblocks_ao(.*)/).test(input.asset) || RegExp(/^tyblocks_ap(.*)/).test(input.asset)) || "object" === typeof input.asset && null !== input.asset && _iu0(input.asset)) && (null !== input.destinationLocation && undefined !== input.destinationLocation && ("string" === typeof input.destinationLocation && (RegExp(/^chain:keeta:[+-]?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/).test(input.destinationLocation) || RegExp(/^chain:evm:[+-]?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/).test(input.destinationLocation)) || "object" === typeof input.destinationLocation && null !== input.destinationLocation && _iu1(input.destinationLocation))) && "string" === typeof input.destinationAddress && (null !== input.sourceLocation && undefined !== input.sourceLocation && ("string" === typeof input.sourceLocation && (RegExp(/^chain:keeta:[+-]?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/).test(input.sourceLocation) || RegExp(/^chain:evm:[+-]?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/).test(input.sourceLocation)) || "object" === typeof input.sourceLocation && null !== input.sourceLocation && _iu1(input.sourceLocation))); const _io1 = input => true && true === _iv1.has(input.code) && "string" === typeof input.name && "string" === typeof input.precision && true === _iv2.has(input.isoNumber); const _io2 = input => true; const _io3 = input => "chain" === input.type && ("object" === typeof input.chain && null !== input.chain && _iu2(input.chain)); const _io4 = input => "keeta" === input.type && "bigint" === typeof input.networkId; const _io5 = input => "evm" === input.type && "bigint" === typeof input.chainId; const _io6 = input => "bank-account" === input.type && (null !== input.workInProgress && undefined === input.workInProgress); const _iu0 = input => (() => {
+    if (undefined !== input.code)
+        return _io1(input);
+    else
+        return _io2(input);
+})(); const _iu1 = input => (() => {
+    if ("chain" === input.type)
+        return _io3(input);
+    else if ("bank-account" === input.type)
+        return _io6(input);
+    else
+        return false;
+})(); const _iu2 = input => (() => {
+    if ("keeta" === input.type)
+        return _io4(input);
+    else if ("evm" === input.type)
+        return _io5(input);
+    else
+        return false;
+})(); const _ao0 = (input, _path, _exceptionable = true) => (null !== input.asset || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".asset",
+    expected: "(Currency | TokenAddress | `keeta_am${string}` | `keeta_an${string}` | `keeta_ao${string}` | `keeta_ap${string}` | `tyblocks_am${string}` | `tyblocks_an${string}` | `tyblocks_ao${string}` | `tyblocks_ap${string}`)",
+    value: input.asset
+}, _errorFactory)) && (undefined !== input.asset || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".asset",
+    expected: "(Currency | TokenAddress | `keeta_am${string}` | `keeta_an${string}` | `keeta_ao${string}` | `keeta_ap${string}` | `tyblocks_am${string}` | `tyblocks_an${string}` | `tyblocks_ao${string}` | `tyblocks_ap${string}`)",
+    value: input.asset
+}, _errorFactory)) && ("string" === typeof input.asset && (RegExp(/^keeta_am(.*)/).test(input.asset) || RegExp(/^keeta_an(.*)/).test(input.asset) || RegExp(/^keeta_ao(.*)/).test(input.asset) || RegExp(/^keeta_ap(.*)/).test(input.asset) || RegExp(/^tyblocks_am(.*)/).test(input.asset) || RegExp(/^tyblocks_an(.*)/).test(input.asset) || RegExp(/^tyblocks_ao(.*)/).test(input.asset) || RegExp(/^tyblocks_ap(.*)/).test(input.asset)) || ("object" === typeof input.asset && null !== input.asset || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".asset",
+    expected: "(Currency | TokenAddress | `keeta_am${string}` | `keeta_an${string}` | `keeta_ao${string}` | `keeta_ap${string}` | `tyblocks_am${string}` | `tyblocks_an${string}` | `tyblocks_ao${string}` | `tyblocks_ap${string}`)",
+    value: input.asset
+}, _errorFactory)) && _au0(input.asset, _path + ".asset", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".asset",
+    expected: "(Currency | TokenAddress | `keeta_am${string}` | `keeta_an${string}` | `keeta_ao${string}` | `keeta_ap${string}` | `tyblocks_am${string}` | `tyblocks_an${string}` | `tyblocks_ao${string}` | `tyblocks_ap${string}`)",
+    value: input.asset
+}, _errorFactory)) && ((null !== input.destinationLocation || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".destinationLocation",
+    expected: "(__type | __type.o3 | `chain:evm:${bigint}` | `chain:keeta:${bigint}`)",
+    value: input.destinationLocation
+}, _errorFactory)) && (undefined !== input.destinationLocation || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".destinationLocation",
+    expected: "(__type | __type.o3 | `chain:evm:${bigint}` | `chain:keeta:${bigint}`)",
+    value: input.destinationLocation
+}, _errorFactory)) && ("string" === typeof input.destinationLocation && (RegExp(/^chain:keeta:[+-]?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/).test(input.destinationLocation) || RegExp(/^chain:evm:[+-]?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/).test(input.destinationLocation)) || ("object" === typeof input.destinationLocation && null !== input.destinationLocation || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".destinationLocation",
+    expected: "(__type | __type.o3 | `chain:evm:${bigint}` | `chain:keeta:${bigint}`)",
+    value: input.destinationLocation
+}, _errorFactory)) && _au1(input.destinationLocation, _path + ".destinationLocation", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".destinationLocation",
+    expected: "(__type | __type.o3 | `chain:evm:${bigint}` | `chain:keeta:${bigint}`)",
+    value: input.destinationLocation
+}, _errorFactory))) && ("string" === typeof input.destinationAddress || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".destinationAddress",
+    expected: "string",
+    value: input.destinationAddress
+}, _errorFactory)) && ((null !== input.sourceLocation || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".sourceLocation",
+    expected: "(__type | __type.o3 | `chain:evm:${bigint}` | `chain:keeta:${bigint}`)",
+    value: input.sourceLocation
+}, _errorFactory)) && (undefined !== input.sourceLocation || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".sourceLocation",
+    expected: "(__type | __type.o3 | `chain:evm:${bigint}` | `chain:keeta:${bigint}`)",
+    value: input.sourceLocation
+}, _errorFactory)) && ("string" === typeof input.sourceLocation && (RegExp(/^chain:keeta:[+-]?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/).test(input.sourceLocation) || RegExp(/^chain:evm:[+-]?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/).test(input.sourceLocation)) || ("object" === typeof input.sourceLocation && null !== input.sourceLocation || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".sourceLocation",
+    expected: "(__type | __type.o3 | `chain:evm:${bigint}` | `chain:keeta:${bigint}`)",
+    value: input.sourceLocation
+}, _errorFactory)) && _au1(input.sourceLocation, _path + ".sourceLocation", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".sourceLocation",
+    expected: "(__type | __type.o3 | `chain:evm:${bigint}` | `chain:keeta:${bigint}`)",
+    value: input.sourceLocation
+}, _errorFactory))); const _ao1 = (input, _path, _exceptionable = true) => true && (true === _av3.has(input.code) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".code",
+    expected: "(\"AED\" | \"AFN\" | \"ALL\" | \"AMD\" | \"ANG\" | \"AOA\" | \"ARS\" | \"AUD\" | \"AWG\" | \"AZN\" | \"BAM\" | \"BBD\" | \"BDT\" | \"BGN\" | \"BHD\" | \"BIF\" | \"BMD\" | \"BND\" | \"BOB\" | \"BOV\" | \"BRL\" | \"BSD\" | \"BTN\" | \"BWP\" | \"BYN\" | \"BZD\" | \"CAD\" | \"CDF\" | \"CHE\" | \"CHF\" | \"CHW\" | \"CLF\" | \"CLP\" | \"CNY\" | \"COP\" | \"COU\" | \"CRC\" | \"CUC\" | \"CUP\" | \"CVE\" | \"CZK\" | \"DJF\" | \"DKK\" | \"DOP\" | \"DZD\" | \"EGP\" | \"ERN\" | \"ETB\" | \"EUR\" | \"FJD\" | \"FKP\" | \"GBP\" | \"GEL\" | \"GHS\" | \"GIP\" | \"GMD\" | \"GNF\" | \"GTQ\" | \"GYD\" | \"HKD\" | \"HNL\" | \"HTG\" | \"HUF\" | \"IDR\" | \"ILS\" | \"INR\" | \"IQD\" | \"IRR\" | \"ISK\" | \"JMD\" | \"JOD\" | \"JPY\" | \"KES\" | \"KGS\" | \"KHR\" | \"KMF\" | \"KPW\" | \"KRW\" | \"KWD\" | \"KYD\" | \"KZT\" | \"LAK\" | \"LBP\" | \"LKR\" | \"LRD\" | \"LSL\" | \"LYD\" | \"MAD\" | \"MDL\" | \"MGA\" | \"MKD\" | \"MMK\" | \"MNT\" | \"MOP\" | \"MRU\" | \"MUR\" | \"MVR\" | \"MWK\" | \"MXN\" | \"MXV\" | \"MYR\" | \"MZN\" | \"NAD\" | \"NGN\" | \"NIO\" | \"NOK\" | \"NPR\" | \"NZD\" | \"OMR\" | \"PAB\" | \"PEN\" | \"PGK\" | \"PHP\" | \"PKR\" | \"PLN\" | \"PYG\" | \"QAR\" | \"RON\" | \"RSD\" | \"RUB\" | \"RWF\" | \"SAR\" | \"SBD\" | \"SCR\" | \"SDG\" | \"SEK\" | \"SGD\" | \"SHP\" | \"SLE\" | \"SLL\" | \"SOS\" | \"SRD\" | \"SSP\" | \"STN\" | \"SVC\" | \"SYP\" | \"SZL\" | \"THB\" | \"TJS\" | \"TMT\" | \"TND\" | \"TOP\" | \"TRY\" | \"TTD\" | \"TWD\" | \"TZS\" | \"UAH\" | \"UGX\" | \"USD\" | \"USN\" | \"UYI\" | \"UYU\" | \"UYW\" | \"UZS\" | \"VED\" | \"VES\" | \"VND\" | \"VUV\" | \"WST\" | \"XAF\" | \"XCD\" | \"XOF\" | \"XPF\" | \"YER\" | \"ZAR\" | \"ZMW\" | \"ZWL\")",
+    value: input.code
+}, _errorFactory)) && ("string" === typeof input.name || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".name",
+    expected: "string",
+    value: input.name
+}, _errorFactory)) && ("string" === typeof input.precision || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".precision",
+    expected: "string",
+    value: input.precision
+}, _errorFactory)) && (true === _av4.has(input.isoNumber) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".isoNumber",
+    expected: "(\"104\" | \"108\" | \"116\" | \"12\" | \"124\" | \"132\" | \"136\" | \"144\" | \"152\" | \"156\" | \"170\" | \"174\" | \"188\" | \"192\" | \"203\" | \"208\" | \"214\" | \"222\" | \"230\" | \"232\" | \"238\" | \"242\" | \"262\" | \"270\" | \"292\" | \"32\" | \"320\" | \"324\" | \"328\" | \"332\" | \"340\" | \"344\" | \"348\" | \"352\" | \"356\" | \"36\" | \"360\" | \"364\" | \"368\" | \"376\" | \"388\" | \"392\" | \"398\" | \"400\" | \"404\" | \"408\" | \"410\" | \"414\" | \"417\" | \"418\" | \"422\" | \"426\" | \"430\" | \"434\" | \"44\" | \"446\" | \"454\" | \"458\" | \"462\" | \"48\" | \"480\" | \"484\" | \"496\" | \"498\" | \"50\" | \"504\" | \"51\" | \"512\" | \"516\" | \"52\" | \"524\" | \"532\" | \"533\" | \"548\" | \"554\" | \"558\" | \"566\" | \"578\" | \"586\" | \"590\" | \"598\" | \"60\" | \"600\" | \"604\" | \"608\" | \"634\" | \"64\" | \"643\" | \"646\" | \"654\" | \"68\" | \"682\" | \"690\" | \"694\" | \"702\" | \"704\" | \"706\" | \"710\" | \"72\" | \"728\" | \"748\" | \"752\" | \"756\" | \"760\" | \"764\" | \"776\" | \"780\" | \"784\" | \"788\" | \"8\" | \"800\" | \"807\" | \"818\" | \"826\" | \"834\" | \"84\" | \"840\" | \"858\" | \"860\" | \"882\" | \"886\" | \"90\" | \"901\" | \"925\" | \"926\" | \"927\" | \"928\" | \"929\" | \"930\" | \"931\" | \"932\" | \"933\" | \"934\" | \"936\" | \"938\" | \"940\" | \"941\" | \"943\" | \"944\" | \"946\" | \"947\" | \"948\" | \"949\" | \"950\" | \"951\" | \"952\" | \"953\" | \"96\" | \"967\" | \"968\" | \"969\" | \"970\" | \"971\" | \"972\" | \"973\" | \"975\" | \"976\" | \"977\" | \"978\" | \"979\" | \"980\" | \"981\" | \"984\" | \"985\" | \"986\" | \"990\" | \"997\")",
+    value: input.isoNumber
+}, _errorFactory)); const _ao2 = (input, _path, _exceptionable = true) => true; const _ao3 = (input, _path, _exceptionable = true) => ("chain" === input.type || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".type",
+    expected: "\"chain\"",
+    value: input.type
+}, _errorFactory)) && (("object" === typeof input.chain && null !== input.chain || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".chain",
+    expected: "(__type.o1 | __type.o2)",
+    value: input.chain
+}, _errorFactory)) && _au2(input.chain, _path + ".chain", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".chain",
+    expected: "(__type.o1 | __type.o2)",
+    value: input.chain
+}, _errorFactory)); const _ao4 = (input, _path, _exceptionable = true) => ("keeta" === input.type || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".type",
+    expected: "\"keeta\"",
+    value: input.type
+}, _errorFactory)) && ("bigint" === typeof input.networkId || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".networkId",
+    expected: "bigint",
+    value: input.networkId
+}, _errorFactory)); const _ao5 = (input, _path, _exceptionable = true) => ("evm" === input.type || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".type",
+    expected: "\"evm\"",
+    value: input.type
+}, _errorFactory)) && ("bigint" === typeof input.chainId || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".chainId",
+    expected: "bigint",
+    value: input.chainId
+}, _errorFactory)); const _ao6 = (input, _path, _exceptionable = true) => ("bank-account" === input.type || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".type",
+    expected: "\"bank-account\"",
+    value: input.type
+}, _errorFactory)) && ((null !== input.workInProgress || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".workInProgress",
+    expected: "undefined",
+    value: input.workInProgress
+}, _errorFactory)) && (undefined === input.workInProgress || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".workInProgress",
+    expected: "undefined",
+    value: input.workInProgress
+}, _errorFactory))); const _au0 = (input, _path, _exceptionable = true) => (() => {
+    if (undefined !== input.code)
+        return _ao1(input, _path, true && _exceptionable);
+    else
+        return _ao2(input, _path, true && _exceptionable);
+})(); const _au1 = (input, _path, _exceptionable = true) => (() => {
+    if ("chain" === input.type)
+        return _ao3(input, _path, true && _exceptionable);
+    else if ("bank-account" === input.type)
+        return _ao6(input, _path, true && _exceptionable);
+    else
+        return __typia_transform__assertGuard._assertGuard(_exceptionable, {
+            method: "createAssert",
+            path: _path,
+            expected: "(__type | __type.o3)",
+            value: input
+        }, _errorFactory);
+})(); const _au2 = (input, _path, _exceptionable = true) => (() => {
+    if ("keeta" === input.type)
+        return _ao4(input, _path, true && _exceptionable);
+    else if ("evm" === input.type)
+        return _ao5(input, _path, true && _exceptionable);
+    else
+        return __typia_transform__assertGuard._assertGuard(_exceptionable, {
+            method: "createAssert",
+            path: _path,
+            expected: "(__type.o1 | __type.o2)",
+            value: input
+        }, _errorFactory);
+})(); const __is = input => "object" === typeof input && null !== input && _io0(input); let _errorFactory; return (input, errorFactory) => {
+    if (false === __is(input)) {
+        _errorFactory = errorFactory;
+        ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || __typia_transform__assertGuard._assertGuard(true, {
+            method: "createAssert",
+            path: _path + "",
+            expected: "KeetaAssetMovementAnchorCreatePersistentForwardingRequest",
+            value: input
+        }, _errorFactory)) && _ao0(input, _path + "", true) || __typia_transform__assertGuard._assertGuard(true, {
+            method: "createAssert",
+            path: _path + "",
+            expected: "KeetaAssetMovementAnchorCreatePersistentForwardingRequest",
+            value: input
+        }, _errorFactory))(input, "$input", true);
+    }
+    return input;
+}; })();
+export const assertKeetaAssetMovementAnchorCreatePersistentForwardingResponse = (() => { const _io0 = (input, _exceptionable = true) => true === input.ok && "string" === typeof input.address && (2 === Object.keys(input).length || Object.keys(input).every(key => {
+    if (["ok", "address"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return false;
+})); const _io1 = (input, _exceptionable = true) => false === input.ok && "string" === typeof input.error && (2 === Object.keys(input).length || Object.keys(input).every(key => {
+    if (["ok", "error"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return false;
+})); const _iu0 = (input, _exceptionable = true) => (() => {
+    if (true === input.ok)
+        return _io0(input, true && _exceptionable);
+    else if (false === input.ok)
+        return _io1(input, true && _exceptionable);
+    else
+        return false;
+})(); const _ao0 = (input, _path, _exceptionable = true) => (true === input.ok || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".ok",
+    expected: "true",
+    value: input.ok
+}, _errorFactory)) && ("string" === typeof input.address || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".address",
+    expected: "string",
+    value: input.address
+}, _errorFactory)) && (2 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every(key => {
+    if (["ok", "address"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return __typia_transform__assertGuard._assertGuard(_exceptionable, {
+        method: "createAssertEquals",
+        path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+        expected: "undefined",
+        value: value
+    }, _errorFactory);
+}))); const _ao1 = (input, _path, _exceptionable = true) => (false === input.ok || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".ok",
+    expected: "false",
+    value: input.ok
+}, _errorFactory)) && ("string" === typeof input.error || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".error",
+    expected: "string",
+    value: input.error
+}, _errorFactory)) && (2 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every(key => {
+    if (["ok", "error"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return __typia_transform__assertGuard._assertGuard(_exceptionable, {
+        method: "createAssertEquals",
+        path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+        expected: "undefined",
+        value: value
+    }, _errorFactory);
+}))); const _au0 = (input, _path, _exceptionable = true) => (() => {
+    if (true === input.ok)
+        return _ao0(input, _path, true && _exceptionable);
+    else if (false === input.ok)
+        return _ao1(input, _path, true && _exceptionable);
+    else
+        return __typia_transform__assertGuard._assertGuard(_exceptionable, {
+            method: "createAssertEquals",
+            path: _path,
+            expected: "(__type | __type.o1)",
+            value: input
+        }, _errorFactory);
+})(); const __is = (input, _exceptionable = true) => "object" === typeof input && null !== input && _iu0(input, true); let _errorFactory; return (input, errorFactory) => {
+    if (false === __is(input)) {
+        _errorFactory = errorFactory;
+        ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || __typia_transform__assertGuard._assertGuard(true, {
+            method: "createAssertEquals",
+            path: _path + "",
+            expected: "(__type | __type.o1)",
+            value: input
+        }, _errorFactory)) && _au0(input, _path + "", true) || __typia_transform__assertGuard._assertGuard(true, {
+            method: "createAssertEquals",
+            path: _path + "",
+            expected: "(__type | __type.o1)",
+            value: input
+        }, _errorFactory))(input, "$input", true);
+    }
+    return input;
+}; })();
+export const assertKeetaAssetMovementAnchorInitiateTransferRequest = (() => { const _iv1 = new Set(["ALL", "AFN", "EUR", "DZD", "USD", "AOA", "XCD", "ARS", "AMD", "AWG", "AUD", "AZN", "BSD", "BHD", "BDT", "BBD", "BYN", "BZD", "XOF", "BMD", "INR", "BTN", "BOB", "BOV", "BAM", "BWP", "NOK", "BRL", "BND", "BGN", "BIF", "CVE", "KHR", "XAF", "CAD", "KYD", "CLP", "CLF", "CNY", "COP", "COU", "KMF", "CDF", "NZD", "CRC", "CUP", "CUC", "ANG", "CZK", "DKK", "DJF", "DOP", "EGP", "SVC", "ERN", "SZL", "ETB", "FKP", "FJD", "XPF", "GMD", "GEL", "GHS", "GIP", "GTQ", "GBP", "GNF", "GYD", "HTG", "HNL", "HKD", "HUF", "ISK", "IDR", "IRR", "IQD", "ILS", "JMD", "JPY", "JOD", "KZT", "KES", "KPW", "KRW", "KWD", "KGS", "LAK", "LBP", "LSL", "ZAR", "LRD", "LYD", "CHF", "MOP", "MKD", "MGA", "MWK", "MYR", "MVR", "MRU", "MUR", "MXN", "MXV", "MDL", "MNT", "MAD", "MZN", "MMK", "NAD", "NPR", "NIO", "NGN", "OMR", "PKR", "PAB", "PGK", "PYG", "PEN", "PHP", "PLN", "QAR", "RON", "RUB", "RWF", "SHP", "WST", "STN", "SAR", "RSD", "SCR", "SLL", "SLE", "SGD", "SBD", "SOS", "SSP", "LKR", "SDG", "SRD", "SEK", "CHE", "CHW", "SYP", "TWD", "TJS", "TZS", "THB", "TOP", "TTD", "TND", "TRY", "TMT", "UGX", "UAH", "AED", "USN", "UYU", "UYI", "UYW", "UZS", "VUV", "VES", "VED", "VND", "YER", "ZMW", "ZWL"]); const _iv2 = new Set(["971", "978", "8", "12", "840", "973", "951", "32", "51", "533", "36", "944", "44", "48", "50", "52", "933", "84", "952", "60", "356", "64", "68", "984", "977", "72", "578", "986", "96", "975", "108", "132", "116", "950", "124", "136", "152", "990", "156", "170", "970", "174", "976", "554", "188", "192", "931", "532", "203", "208", "262", "214", "818", "222", "232", "748", "230", "238", "242", "953", "270", "981", "936", "292", "320", "826", "324", "328", "332", "340", "344", "348", "352", "360", "364", "368", "376", "388", "392", "400", "398", "404", "408", "410", "414", "417", "418", "422", "426", "710", "430", "434", "756", "446", "807", "969", "454", "458", "462", "929", "480", "484", "979", "498", "496", "504", "943", "104", "516", "524", "558", "566", "512", "586", "590", "598", "600", "604", "608", "985", "634", "946", "643", "646", "654", "882", "930", "682", "941", "690", "694", "925", "702", "90", "706", "728", "144", "938", "968", "752", "947", "948", "760", "901", "972", "834", "764", "776", "780", "788", "949", "934", "800", "980", "784", "997", "858", "940", "927", "860", "548", "928", "926", "704", "886", "967", "932"]); const _av3 = new Set(["ALL", "AFN", "EUR", "DZD", "USD", "AOA", "XCD", "ARS", "AMD", "AWG", "AUD", "AZN", "BSD", "BHD", "BDT", "BBD", "BYN", "BZD", "XOF", "BMD", "INR", "BTN", "BOB", "BOV", "BAM", "BWP", "NOK", "BRL", "BND", "BGN", "BIF", "CVE", "KHR", "XAF", "CAD", "KYD", "CLP", "CLF", "CNY", "COP", "COU", "KMF", "CDF", "NZD", "CRC", "CUP", "CUC", "ANG", "CZK", "DKK", "DJF", "DOP", "EGP", "SVC", "ERN", "SZL", "ETB", "FKP", "FJD", "XPF", "GMD", "GEL", "GHS", "GIP", "GTQ", "GBP", "GNF", "GYD", "HTG", "HNL", "HKD", "HUF", "ISK", "IDR", "IRR", "IQD", "ILS", "JMD", "JPY", "JOD", "KZT", "KES", "KPW", "KRW", "KWD", "KGS", "LAK", "LBP", "LSL", "ZAR", "LRD", "LYD", "CHF", "MOP", "MKD", "MGA", "MWK", "MYR", "MVR", "MRU", "MUR", "MXN", "MXV", "MDL", "MNT", "MAD", "MZN", "MMK", "NAD", "NPR", "NIO", "NGN", "OMR", "PKR", "PAB", "PGK", "PYG", "PEN", "PHP", "PLN", "QAR", "RON", "RUB", "RWF", "SHP", "WST", "STN", "SAR", "RSD", "SCR", "SLL", "SLE", "SGD", "SBD", "SOS", "SSP", "LKR", "SDG", "SRD", "SEK", "CHE", "CHW", "SYP", "TWD", "TJS", "TZS", "THB", "TOP", "TTD", "TND", "TRY", "TMT", "UGX", "UAH", "AED", "USN", "UYU", "UYI", "UYW", "UZS", "VUV", "VES", "VED", "VND", "YER", "ZMW", "ZWL"]); const _av4 = new Set(["971", "978", "8", "12", "840", "973", "951", "32", "51", "533", "36", "944", "44", "48", "50", "52", "933", "84", "952", "60", "356", "64", "68", "984", "977", "72", "578", "986", "96", "975", "108", "132", "116", "950", "124", "136", "152", "990", "156", "170", "970", "174", "976", "554", "188", "192", "931", "532", "203", "208", "262", "214", "818", "222", "232", "748", "230", "238", "242", "953", "270", "981", "936", "292", "320", "826", "324", "328", "332", "340", "344", "348", "352", "360", "364", "368", "376", "388", "392", "400", "398", "404", "408", "410", "414", "417", "418", "422", "426", "710", "430", "434", "756", "446", "807", "969", "454", "458", "462", "929", "480", "484", "979", "498", "496", "504", "943", "104", "516", "524", "558", "566", "512", "586", "590", "598", "600", "604", "608", "985", "634", "946", "643", "646", "654", "882", "930", "682", "941", "690", "694", "925", "702", "90", "706", "728", "144", "938", "968", "752", "947", "948", "760", "901", "972", "834", "764", "776", "780", "788", "949", "934", "800", "980", "784", "997", "858", "940", "927", "860", "548", "928", "926", "704", "886", "967", "932"]); const _io0 = input => null !== input.asset && undefined !== input.asset && ("string" === typeof input.asset && (RegExp(/^keeta_am(.*)/).test(input.asset) || RegExp(/^keeta_an(.*)/).test(input.asset) || RegExp(/^keeta_ao(.*)/).test(input.asset) || RegExp(/^keeta_ap(.*)/).test(input.asset) || RegExp(/^tyblocks_am(.*)/).test(input.asset) || RegExp(/^tyblocks_an(.*)/).test(input.asset) || RegExp(/^tyblocks_ao(.*)/).test(input.asset) || RegExp(/^tyblocks_ap(.*)/).test(input.asset)) || "object" === typeof input.asset && null !== input.asset && _iu0(input.asset)) && ("object" === typeof input.from && null !== input.from && _io3(input.from)) && ("object" === typeof input.to && null !== input.to && _io8(input.to)) && "string" === typeof input.value && (undefined === input.allowedRails || Array.isArray(input.allowedRails)); const _io1 = input => true && true === _iv1.has(input.code) && "string" === typeof input.name && "string" === typeof input.precision && true === _iv2.has(input.isoNumber); const _io2 = input => true; const _io3 = input => null !== input.location && undefined !== input.location && ("string" === typeof input.location && (RegExp(/^chain:keeta:[+-]?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/).test(input.location) || RegExp(/^chain:evm:[+-]?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/).test(input.location)) || "object" === typeof input.location && null !== input.location && _iu1(input.location)); const _io4 = input => "chain" === input.type && ("object" === typeof input.chain && null !== input.chain && _iu2(input.chain)); const _io5 = input => "keeta" === input.type && "bigint" === typeof input.networkId; const _io6 = input => "evm" === input.type && "bigint" === typeof input.chainId; const _io7 = input => "bank-account" === input.type && (null !== input.workInProgress && undefined === input.workInProgress); const _io8 = input => null !== input.location && undefined !== input.location && ("string" === typeof input.location && (RegExp(/^chain:keeta:[+-]?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/).test(input.location) || RegExp(/^chain:evm:[+-]?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/).test(input.location)) || "object" === typeof input.location && null !== input.location && _iu1(input.location)) && "string" === typeof input.recipient; const _iu0 = input => (() => {
+    if (undefined !== input.code)
+        return _io1(input);
+    else
+        return _io2(input);
+})(); const _iu1 = input => (() => {
+    if ("chain" === input.type)
+        return _io4(input);
+    else if ("bank-account" === input.type)
+        return _io7(input);
+    else
+        return false;
+})(); const _iu2 = input => (() => {
+    if ("keeta" === input.type)
+        return _io5(input);
+    else if ("evm" === input.type)
+        return _io6(input);
+    else
+        return false;
+})(); const _ao0 = (input, _path, _exceptionable = true) => (null !== input.asset || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".asset",
+    expected: "(Currency | TokenAddress | `keeta_am${string}` | `keeta_an${string}` | `keeta_ao${string}` | `keeta_ap${string}` | `tyblocks_am${string}` | `tyblocks_an${string}` | `tyblocks_ao${string}` | `tyblocks_ap${string}`)",
+    value: input.asset
+}, _errorFactory)) && (undefined !== input.asset || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".asset",
+    expected: "(Currency | TokenAddress | `keeta_am${string}` | `keeta_an${string}` | `keeta_ao${string}` | `keeta_ap${string}` | `tyblocks_am${string}` | `tyblocks_an${string}` | `tyblocks_ao${string}` | `tyblocks_ap${string}`)",
+    value: input.asset
+}, _errorFactory)) && ("string" === typeof input.asset && (RegExp(/^keeta_am(.*)/).test(input.asset) || RegExp(/^keeta_an(.*)/).test(input.asset) || RegExp(/^keeta_ao(.*)/).test(input.asset) || RegExp(/^keeta_ap(.*)/).test(input.asset) || RegExp(/^tyblocks_am(.*)/).test(input.asset) || RegExp(/^tyblocks_an(.*)/).test(input.asset) || RegExp(/^tyblocks_ao(.*)/).test(input.asset) || RegExp(/^tyblocks_ap(.*)/).test(input.asset)) || ("object" === typeof input.asset && null !== input.asset || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".asset",
+    expected: "(Currency | TokenAddress | `keeta_am${string}` | `keeta_an${string}` | `keeta_ao${string}` | `keeta_ap${string}` | `tyblocks_am${string}` | `tyblocks_an${string}` | `tyblocks_ao${string}` | `tyblocks_ap${string}`)",
+    value: input.asset
+}, _errorFactory)) && _au0(input.asset, _path + ".asset", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".asset",
+    expected: "(Currency | TokenAddress | `keeta_am${string}` | `keeta_an${string}` | `keeta_ao${string}` | `keeta_ap${string}` | `tyblocks_am${string}` | `tyblocks_an${string}` | `tyblocks_ao${string}` | `tyblocks_ap${string}`)",
+    value: input.asset
+}, _errorFactory)) && (("object" === typeof input.from && null !== input.from || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".from",
+    expected: "__type",
+    value: input.from
+}, _errorFactory)) && _ao3(input.from, _path + ".from", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".from",
+    expected: "__type",
+    value: input.from
+}, _errorFactory)) && (("object" === typeof input.to && null !== input.to || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".to",
+    expected: "__type.o5",
+    value: input.to
+}, _errorFactory)) && _ao8(input.to, _path + ".to", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".to",
+    expected: "__type.o5",
+    value: input.to
+}, _errorFactory)) && ("string" === typeof input.value || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".value",
+    expected: "string",
+    value: input.value
+}, _errorFactory)) && (undefined === input.allowedRails || Array.isArray(input.allowedRails) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".allowedRails",
+    expected: "(Array<unknown> | undefined)",
+    value: input.allowedRails
+}, _errorFactory)); const _ao1 = (input, _path, _exceptionable = true) => true && (true === _av3.has(input.code) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".code",
+    expected: "(\"AED\" | \"AFN\" | \"ALL\" | \"AMD\" | \"ANG\" | \"AOA\" | \"ARS\" | \"AUD\" | \"AWG\" | \"AZN\" | \"BAM\" | \"BBD\" | \"BDT\" | \"BGN\" | \"BHD\" | \"BIF\" | \"BMD\" | \"BND\" | \"BOB\" | \"BOV\" | \"BRL\" | \"BSD\" | \"BTN\" | \"BWP\" | \"BYN\" | \"BZD\" | \"CAD\" | \"CDF\" | \"CHE\" | \"CHF\" | \"CHW\" | \"CLF\" | \"CLP\" | \"CNY\" | \"COP\" | \"COU\" | \"CRC\" | \"CUC\" | \"CUP\" | \"CVE\" | \"CZK\" | \"DJF\" | \"DKK\" | \"DOP\" | \"DZD\" | \"EGP\" | \"ERN\" | \"ETB\" | \"EUR\" | \"FJD\" | \"FKP\" | \"GBP\" | \"GEL\" | \"GHS\" | \"GIP\" | \"GMD\" | \"GNF\" | \"GTQ\" | \"GYD\" | \"HKD\" | \"HNL\" | \"HTG\" | \"HUF\" | \"IDR\" | \"ILS\" | \"INR\" | \"IQD\" | \"IRR\" | \"ISK\" | \"JMD\" | \"JOD\" | \"JPY\" | \"KES\" | \"KGS\" | \"KHR\" | \"KMF\" | \"KPW\" | \"KRW\" | \"KWD\" | \"KYD\" | \"KZT\" | \"LAK\" | \"LBP\" | \"LKR\" | \"LRD\" | \"LSL\" | \"LYD\" | \"MAD\" | \"MDL\" | \"MGA\" | \"MKD\" | \"MMK\" | \"MNT\" | \"MOP\" | \"MRU\" | \"MUR\" | \"MVR\" | \"MWK\" | \"MXN\" | \"MXV\" | \"MYR\" | \"MZN\" | \"NAD\" | \"NGN\" | \"NIO\" | \"NOK\" | \"NPR\" | \"NZD\" | \"OMR\" | \"PAB\" | \"PEN\" | \"PGK\" | \"PHP\" | \"PKR\" | \"PLN\" | \"PYG\" | \"QAR\" | \"RON\" | \"RSD\" | \"RUB\" | \"RWF\" | \"SAR\" | \"SBD\" | \"SCR\" | \"SDG\" | \"SEK\" | \"SGD\" | \"SHP\" | \"SLE\" | \"SLL\" | \"SOS\" | \"SRD\" | \"SSP\" | \"STN\" | \"SVC\" | \"SYP\" | \"SZL\" | \"THB\" | \"TJS\" | \"TMT\" | \"TND\" | \"TOP\" | \"TRY\" | \"TTD\" | \"TWD\" | \"TZS\" | \"UAH\" | \"UGX\" | \"USD\" | \"USN\" | \"UYI\" | \"UYU\" | \"UYW\" | \"UZS\" | \"VED\" | \"VES\" | \"VND\" | \"VUV\" | \"WST\" | \"XAF\" | \"XCD\" | \"XOF\" | \"XPF\" | \"YER\" | \"ZAR\" | \"ZMW\" | \"ZWL\")",
+    value: input.code
+}, _errorFactory)) && ("string" === typeof input.name || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".name",
+    expected: "string",
+    value: input.name
+}, _errorFactory)) && ("string" === typeof input.precision || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".precision",
+    expected: "string",
+    value: input.precision
+}, _errorFactory)) && (true === _av4.has(input.isoNumber) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".isoNumber",
+    expected: "(\"104\" | \"108\" | \"116\" | \"12\" | \"124\" | \"132\" | \"136\" | \"144\" | \"152\" | \"156\" | \"170\" | \"174\" | \"188\" | \"192\" | \"203\" | \"208\" | \"214\" | \"222\" | \"230\" | \"232\" | \"238\" | \"242\" | \"262\" | \"270\" | \"292\" | \"32\" | \"320\" | \"324\" | \"328\" | \"332\" | \"340\" | \"344\" | \"348\" | \"352\" | \"356\" | \"36\" | \"360\" | \"364\" | \"368\" | \"376\" | \"388\" | \"392\" | \"398\" | \"400\" | \"404\" | \"408\" | \"410\" | \"414\" | \"417\" | \"418\" | \"422\" | \"426\" | \"430\" | \"434\" | \"44\" | \"446\" | \"454\" | \"458\" | \"462\" | \"48\" | \"480\" | \"484\" | \"496\" | \"498\" | \"50\" | \"504\" | \"51\" | \"512\" | \"516\" | \"52\" | \"524\" | \"532\" | \"533\" | \"548\" | \"554\" | \"558\" | \"566\" | \"578\" | \"586\" | \"590\" | \"598\" | \"60\" | \"600\" | \"604\" | \"608\" | \"634\" | \"64\" | \"643\" | \"646\" | \"654\" | \"68\" | \"682\" | \"690\" | \"694\" | \"702\" | \"704\" | \"706\" | \"710\" | \"72\" | \"728\" | \"748\" | \"752\" | \"756\" | \"760\" | \"764\" | \"776\" | \"780\" | \"784\" | \"788\" | \"8\" | \"800\" | \"807\" | \"818\" | \"826\" | \"834\" | \"84\" | \"840\" | \"858\" | \"860\" | \"882\" | \"886\" | \"90\" | \"901\" | \"925\" | \"926\" | \"927\" | \"928\" | \"929\" | \"930\" | \"931\" | \"932\" | \"933\" | \"934\" | \"936\" | \"938\" | \"940\" | \"941\" | \"943\" | \"944\" | \"946\" | \"947\" | \"948\" | \"949\" | \"950\" | \"951\" | \"952\" | \"953\" | \"96\" | \"967\" | \"968\" | \"969\" | \"970\" | \"971\" | \"972\" | \"973\" | \"975\" | \"976\" | \"977\" | \"978\" | \"979\" | \"980\" | \"981\" | \"984\" | \"985\" | \"986\" | \"990\" | \"997\")",
+    value: input.isoNumber
+}, _errorFactory)); const _ao2 = (input, _path, _exceptionable = true) => true; const _ao3 = (input, _path, _exceptionable = true) => (null !== input.location || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".location",
+    expected: "(__type.o1 | __type.o4 | `chain:evm:${bigint}` | `chain:keeta:${bigint}`)",
+    value: input.location
+}, _errorFactory)) && (undefined !== input.location || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".location",
+    expected: "(__type.o1 | __type.o4 | `chain:evm:${bigint}` | `chain:keeta:${bigint}`)",
+    value: input.location
+}, _errorFactory)) && ("string" === typeof input.location && (RegExp(/^chain:keeta:[+-]?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/).test(input.location) || RegExp(/^chain:evm:[+-]?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/).test(input.location)) || ("object" === typeof input.location && null !== input.location || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".location",
+    expected: "(__type.o1 | __type.o4 | `chain:evm:${bigint}` | `chain:keeta:${bigint}`)",
+    value: input.location
+}, _errorFactory)) && _au1(input.location, _path + ".location", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".location",
+    expected: "(__type.o1 | __type.o4 | `chain:evm:${bigint}` | `chain:keeta:${bigint}`)",
+    value: input.location
+}, _errorFactory)); const _ao4 = (input, _path, _exceptionable = true) => ("chain" === input.type || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".type",
+    expected: "\"chain\"",
+    value: input.type
+}, _errorFactory)) && (("object" === typeof input.chain && null !== input.chain || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".chain",
+    expected: "(__type.o2 | __type.o3)",
+    value: input.chain
+}, _errorFactory)) && _au2(input.chain, _path + ".chain", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".chain",
+    expected: "(__type.o2 | __type.o3)",
+    value: input.chain
+}, _errorFactory)); const _ao5 = (input, _path, _exceptionable = true) => ("keeta" === input.type || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".type",
+    expected: "\"keeta\"",
+    value: input.type
+}, _errorFactory)) && ("bigint" === typeof input.networkId || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".networkId",
+    expected: "bigint",
+    value: input.networkId
+}, _errorFactory)); const _ao6 = (input, _path, _exceptionable = true) => ("evm" === input.type || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".type",
+    expected: "\"evm\"",
+    value: input.type
+}, _errorFactory)) && ("bigint" === typeof input.chainId || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".chainId",
+    expected: "bigint",
+    value: input.chainId
+}, _errorFactory)); const _ao7 = (input, _path, _exceptionable = true) => ("bank-account" === input.type || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".type",
+    expected: "\"bank-account\"",
+    value: input.type
+}, _errorFactory)) && ((null !== input.workInProgress || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".workInProgress",
+    expected: "undefined",
+    value: input.workInProgress
+}, _errorFactory)) && (undefined === input.workInProgress || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".workInProgress",
+    expected: "undefined",
+    value: input.workInProgress
+}, _errorFactory))); const _ao8 = (input, _path, _exceptionable = true) => (null !== input.location || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".location",
+    expected: "(__type.o1 | __type.o4 | `chain:evm:${bigint}` | `chain:keeta:${bigint}`)",
+    value: input.location
+}, _errorFactory)) && (undefined !== input.location || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".location",
+    expected: "(__type.o1 | __type.o4 | `chain:evm:${bigint}` | `chain:keeta:${bigint}`)",
+    value: input.location
+}, _errorFactory)) && ("string" === typeof input.location && (RegExp(/^chain:keeta:[+-]?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/).test(input.location) || RegExp(/^chain:evm:[+-]?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/).test(input.location)) || ("object" === typeof input.location && null !== input.location || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".location",
+    expected: "(__type.o1 | __type.o4 | `chain:evm:${bigint}` | `chain:keeta:${bigint}`)",
+    value: input.location
+}, _errorFactory)) && _au1(input.location, _path + ".location", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".location",
+    expected: "(__type.o1 | __type.o4 | `chain:evm:${bigint}` | `chain:keeta:${bigint}`)",
+    value: input.location
+}, _errorFactory)) && ("string" === typeof input.recipient || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".recipient",
+    expected: "string",
+    value: input.recipient
+}, _errorFactory)); const _au0 = (input, _path, _exceptionable = true) => (() => {
+    if (undefined !== input.code)
+        return _ao1(input, _path, true && _exceptionable);
+    else
+        return _ao2(input, _path, true && _exceptionable);
+})(); const _au1 = (input, _path, _exceptionable = true) => (() => {
+    if ("chain" === input.type)
+        return _ao4(input, _path, true && _exceptionable);
+    else if ("bank-account" === input.type)
+        return _ao7(input, _path, true && _exceptionable);
+    else
+        return __typia_transform__assertGuard._assertGuard(_exceptionable, {
+            method: "createAssert",
+            path: _path,
+            expected: "(__type.o1 | __type.o4)",
+            value: input
+        }, _errorFactory);
+})(); const _au2 = (input, _path, _exceptionable = true) => (() => {
+    if ("keeta" === input.type)
+        return _ao5(input, _path, true && _exceptionable);
+    else if ("evm" === input.type)
+        return _ao6(input, _path, true && _exceptionable);
+    else
+        return __typia_transform__assertGuard._assertGuard(_exceptionable, {
+            method: "createAssert",
+            path: _path,
+            expected: "(__type.o2 | __type.o3)",
+            value: input
+        }, _errorFactory);
+})(); const __is = input => "object" === typeof input && null !== input && _io0(input); let _errorFactory; return (input, errorFactory) => {
+    if (false === __is(input)) {
+        _errorFactory = errorFactory;
+        ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || __typia_transform__assertGuard._assertGuard(true, {
+            method: "createAssert",
+            path: _path + "",
+            expected: "KeetaAssetMovementAnchorInitiateTransferRequest",
+            value: input
+        }, _errorFactory)) && _ao0(input, _path + "", true) || __typia_transform__assertGuard._assertGuard(true, {
+            method: "createAssert",
+            path: _path + "",
+            expected: "KeetaAssetMovementAnchorInitiateTransferRequest",
+            value: input
+        }, _errorFactory))(input, "$input", true);
+    }
+    return input;
+}; })();
+export const assertKeetaAssetMovementAnchorInitiateTransferResponse = (() => { const _io0 = (input, _exceptionable = true) => true === input.ok && "string" === typeof input.id && (Array.isArray(input.instructionChoices) && input.instructionChoices.every((elem, _index1) => "object" === typeof elem && null !== elem && _iu0(elem, true && _exceptionable))) && (3 === Object.keys(input).length || Object.keys(input).every(key => {
+    if (["ok", "id", "instructionChoices"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return false;
+})); const _io1 = (input, _exceptionable = true) => "KEETA_SEND" === input.type && (null !== input.location && undefined !== input.location && ("string" === typeof input.location && (RegExp(/^chain:keeta:[+-]?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/).test(input.location) || RegExp(/^chain:evm:[+-]?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/).test(input.location)) || "object" === typeof input.location && null !== input.location && _iu1(input.location, true && _exceptionable))) && "string" === typeof input.sendToAddress && "string" === typeof input.value && "string" === typeof input.tokenAddress && (undefined === input.external || "string" === typeof input.external) && "string" === typeof input.assetFee && (6 === Object.keys(input).length || Object.keys(input).every(key => {
+    if (["type", "location", "sendToAddress", "value", "tokenAddress", "external", "assetFee"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return false;
+})); const _io2 = (input, _exceptionable = true) => "chain" === input.type && ("object" === typeof input.chain && null !== input.chain && _iu2(input.chain, true && _exceptionable)) && (2 === Object.keys(input).length || Object.keys(input).every(key => {
+    if (["type", "chain"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return false;
+})); const _io3 = (input, _exceptionable = true) => "keeta" === input.type && "bigint" === typeof input.networkId && (2 === Object.keys(input).length || Object.keys(input).every(key => {
+    if (["type", "networkId"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return false;
+})); const _io4 = (input, _exceptionable = true) => "evm" === input.type && "bigint" === typeof input.chainId && (2 === Object.keys(input).length || Object.keys(input).every(key => {
+    if (["type", "chainId"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return false;
+})); const _io5 = (input, _exceptionable = true) => "bank-account" === input.type && (null !== input.workInProgress && undefined === input.workInProgress) && (1 === Object.keys(input).length || Object.keys(input).every(key => {
+    if (["type", "workInProgress"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return false;
+})); const _io6 = (input, _exceptionable = true) => "EVM_SEND" === input.type && (null !== input.location && undefined !== input.location && ("string" === typeof input.location && (RegExp(/^chain:keeta:[+-]?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/).test(input.location) || RegExp(/^chain:evm:[+-]?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/).test(input.location)) || "object" === typeof input.location && null !== input.location && _iu1(input.location, true && _exceptionable))) && "string" === typeof input.sendToAddress && "string" === typeof input.value && ("string" === typeof input.tokenAddress && RegExp(/^0x(.*)/).test(input.tokenAddress)) && "string" === typeof input.assetFee && (6 === Object.keys(input).length || Object.keys(input).every(key => {
+    if (["type", "location", "sendToAddress", "value", "tokenAddress", "assetFee"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return false;
+})); const _io7 = (input, _exceptionable = true) => "EVM_CALL" === input.type && (null !== input.location && undefined !== input.location && ("string" === typeof input.location && (RegExp(/^chain:keeta:[+-]?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/).test(input.location) || RegExp(/^chain:evm:[+-]?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/).test(input.location)) || "object" === typeof input.location && null !== input.location && _iu1(input.location, true && _exceptionable))) && "string" === typeof input.contractAddress && "string" === typeof input.contractMethodName && (Array.isArray(input.contractMethodArgs) && input.contractMethodArgs.every((elem, _index2) => "string" === typeof elem)) && "string" === typeof input.assetFee && (6 === Object.keys(input).length || Object.keys(input).every(key => {
+    if (["type", "location", "contractAddress", "contractMethodName", "contractMethodArgs", "assetFee"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return false;
+})); const _io8 = (input, _exceptionable = true) => false === input.ok && "string" === typeof input.error && (2 === Object.keys(input).length || Object.keys(input).every(key => {
+    if (["ok", "error"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return false;
+})); const _iu0 = (input, _exceptionable = true) => (() => {
+    if ("KEETA_SEND" === input.type)
+        return _io1(input, true && _exceptionable);
+    else if ("EVM_SEND" === input.type)
+        return _io6(input, true && _exceptionable);
+    else if ("EVM_CALL" === input.type)
+        return _io7(input, true && _exceptionable);
+    else
+        return false;
+})(); const _iu1 = (input, _exceptionable = true) => (() => {
+    if ("chain" === input.type)
+        return _io2(input, true && _exceptionable);
+    else if ("bank-account" === input.type)
+        return _io5(input, true && _exceptionable);
+    else
+        return false;
+})(); const _iu2 = (input, _exceptionable = true) => (() => {
+    if ("keeta" === input.type)
+        return _io3(input, true && _exceptionable);
+    else if ("evm" === input.type)
+        return _io4(input, true && _exceptionable);
+    else
+        return false;
+})(); const _iu3 = (input, _exceptionable = true) => (() => {
+    if (true === input.ok)
+        return _io0(input, true && _exceptionable);
+    else if (false === input.ok)
+        return _io8(input, true && _exceptionable);
+    else
+        return false;
+})(); const _ao0 = (input, _path, _exceptionable = true) => (true === input.ok || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".ok",
+    expected: "true",
+    value: input.ok
+}, _errorFactory)) && ("string" === typeof input.id || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".id",
+    expected: "string",
+    value: input.id
+}, _errorFactory)) && ((Array.isArray(input.instructionChoices) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".instructionChoices",
+    expected: "Array<AssetTransferInstructions>",
+    value: input.instructionChoices
+}, _errorFactory)) && input.instructionChoices.every((elem, _index3) => ("object" === typeof elem && null !== elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".instructionChoices[" + _index3 + "]",
+    expected: "({ type: \"EVM_CALL\"; location: AssetLocationLike; contractAddress: string; contractMethodName: string; contractMethodArgs: string[]; } & { assetFee: string; } | { type: \"EVM_SEND\"; location: AssetLocationLike; sendToAddress: string; value: string; tokenAddress: `0x${string}`; } & { assetFee: string; } | { type: \"KEETA_SEND\"; location: AssetLocationLike; sendToAddress: string; value: string; tokenAddress: string; external?: string; } & { assetFee: string; })",
+    value: elem
+}, _errorFactory)) && _au0(elem, _path + ".instructionChoices[" + _index3 + "]", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".instructionChoices[" + _index3 + "]",
+    expected: "({ type: \"EVM_CALL\"; location: AssetLocationLike; contractAddress: string; contractMethodName: string; contractMethodArgs: string[]; } & { assetFee: string; } | { type: \"EVM_SEND\"; location: AssetLocationLike; sendToAddress: string; value: string; tokenAddress: `0x${string}`; } & { assetFee: string; } | { type: \"KEETA_SEND\"; location: AssetLocationLike; sendToAddress: string; value: string; tokenAddress: string; external?: string; } & { assetFee: string; })",
+    value: elem
+}, _errorFactory)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".instructionChoices",
+    expected: "Array<AssetTransferInstructions>",
+    value: input.instructionChoices
+}, _errorFactory)) && (3 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every(key => {
+    if (["ok", "id", "instructionChoices"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return __typia_transform__assertGuard._assertGuard(_exceptionable, {
+        method: "createAssertEquals",
+        path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+        expected: "undefined",
+        value: value
+    }, _errorFactory);
+}))); const _ao1 = (input, _path, _exceptionable = true) => ("KEETA_SEND" === input.type || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".type",
+    expected: "\"KEETA_SEND\"",
+    value: input.type
+}, _errorFactory)) && ((null !== input.location || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".location",
+    expected: "(__type.o2 | __type.o5 | `chain:evm:${bigint}` | `chain:keeta:${bigint}`)",
+    value: input.location
+}, _errorFactory)) && (undefined !== input.location || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".location",
+    expected: "(__type.o2 | __type.o5 | `chain:evm:${bigint}` | `chain:keeta:${bigint}`)",
+    value: input.location
+}, _errorFactory)) && ("string" === typeof input.location && (RegExp(/^chain:keeta:[+-]?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/).test(input.location) || RegExp(/^chain:evm:[+-]?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/).test(input.location)) || ("object" === typeof input.location && null !== input.location || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".location",
+    expected: "(__type.o2 | __type.o5 | `chain:evm:${bigint}` | `chain:keeta:${bigint}`)",
+    value: input.location
+}, _errorFactory)) && _au1(input.location, _path + ".location", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".location",
+    expected: "(__type.o2 | __type.o5 | `chain:evm:${bigint}` | `chain:keeta:${bigint}`)",
+    value: input.location
+}, _errorFactory))) && ("string" === typeof input.sendToAddress || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".sendToAddress",
+    expected: "string",
+    value: input.sendToAddress
+}, _errorFactory)) && ("string" === typeof input.value || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".value",
+    expected: "string",
+    value: input.value
+}, _errorFactory)) && ("string" === typeof input.tokenAddress || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".tokenAddress",
+    expected: "string",
+    value: input.tokenAddress
+}, _errorFactory)) && (undefined === input.external || "string" === typeof input.external || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".external",
+    expected: "(string | undefined)",
+    value: input.external
+}, _errorFactory)) && ("string" === typeof input.assetFee || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".assetFee",
+    expected: "string",
+    value: input.assetFee
+}, _errorFactory)) && (6 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every(key => {
+    if (["type", "location", "sendToAddress", "value", "tokenAddress", "external", "assetFee"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return __typia_transform__assertGuard._assertGuard(_exceptionable, {
+        method: "createAssertEquals",
+        path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+        expected: "undefined",
+        value: value
+    }, _errorFactory);
+}))); const _ao2 = (input, _path, _exceptionable = true) => ("chain" === input.type || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".type",
+    expected: "\"chain\"",
+    value: input.type
+}, _errorFactory)) && (("object" === typeof input.chain && null !== input.chain || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".chain",
+    expected: "(__type.o3 | __type.o4)",
+    value: input.chain
+}, _errorFactory)) && _au2(input.chain, _path + ".chain", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".chain",
+    expected: "(__type.o3 | __type.o4)",
+    value: input.chain
+}, _errorFactory)) && (2 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every(key => {
+    if (["type", "chain"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return __typia_transform__assertGuard._assertGuard(_exceptionable, {
+        method: "createAssertEquals",
+        path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+        expected: "undefined",
+        value: value
+    }, _errorFactory);
+}))); const _ao3 = (input, _path, _exceptionable = true) => ("keeta" === input.type || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".type",
+    expected: "\"keeta\"",
+    value: input.type
+}, _errorFactory)) && ("bigint" === typeof input.networkId || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".networkId",
+    expected: "bigint",
+    value: input.networkId
+}, _errorFactory)) && (2 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every(key => {
+    if (["type", "networkId"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return __typia_transform__assertGuard._assertGuard(_exceptionable, {
+        method: "createAssertEquals",
+        path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+        expected: "undefined",
+        value: value
+    }, _errorFactory);
+}))); const _ao4 = (input, _path, _exceptionable = true) => ("evm" === input.type || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".type",
+    expected: "\"evm\"",
+    value: input.type
+}, _errorFactory)) && ("bigint" === typeof input.chainId || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".chainId",
+    expected: "bigint",
+    value: input.chainId
+}, _errorFactory)) && (2 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every(key => {
+    if (["type", "chainId"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return __typia_transform__assertGuard._assertGuard(_exceptionable, {
+        method: "createAssertEquals",
+        path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+        expected: "undefined",
+        value: value
+    }, _errorFactory);
+}))); const _ao5 = (input, _path, _exceptionable = true) => ("bank-account" === input.type || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".type",
+    expected: "\"bank-account\"",
+    value: input.type
+}, _errorFactory)) && ((null !== input.workInProgress || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".workInProgress",
+    expected: "undefined",
+    value: input.workInProgress
+}, _errorFactory)) && (undefined === input.workInProgress || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".workInProgress",
+    expected: "undefined",
+    value: input.workInProgress
+}, _errorFactory))) && (1 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every(key => {
+    if (["type", "workInProgress"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return __typia_transform__assertGuard._assertGuard(_exceptionable, {
+        method: "createAssertEquals",
+        path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+        expected: "undefined",
+        value: value
+    }, _errorFactory);
+}))); const _ao6 = (input, _path, _exceptionable = true) => ("EVM_SEND" === input.type || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".type",
+    expected: "\"EVM_SEND\"",
+    value: input.type
+}, _errorFactory)) && ((null !== input.location || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".location",
+    expected: "(__type.o2 | __type.o5 | `chain:evm:${bigint}` | `chain:keeta:${bigint}`)",
+    value: input.location
+}, _errorFactory)) && (undefined !== input.location || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".location",
+    expected: "(__type.o2 | __type.o5 | `chain:evm:${bigint}` | `chain:keeta:${bigint}`)",
+    value: input.location
+}, _errorFactory)) && ("string" === typeof input.location && (RegExp(/^chain:keeta:[+-]?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/).test(input.location) || RegExp(/^chain:evm:[+-]?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/).test(input.location)) || ("object" === typeof input.location && null !== input.location || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".location",
+    expected: "(__type.o2 | __type.o5 | `chain:evm:${bigint}` | `chain:keeta:${bigint}`)",
+    value: input.location
+}, _errorFactory)) && _au1(input.location, _path + ".location", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".location",
+    expected: "(__type.o2 | __type.o5 | `chain:evm:${bigint}` | `chain:keeta:${bigint}`)",
+    value: input.location
+}, _errorFactory))) && ("string" === typeof input.sendToAddress || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".sendToAddress",
+    expected: "string",
+    value: input.sendToAddress
+}, _errorFactory)) && ("string" === typeof input.value || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".value",
+    expected: "string",
+    value: input.value
+}, _errorFactory)) && ("string" === typeof input.tokenAddress && RegExp(/^0x(.*)/).test(input.tokenAddress) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".tokenAddress",
+    expected: "`0x${string}`",
+    value: input.tokenAddress
+}, _errorFactory)) && ("string" === typeof input.assetFee || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".assetFee",
+    expected: "string",
+    value: input.assetFee
+}, _errorFactory)) && (6 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every(key => {
+    if (["type", "location", "sendToAddress", "value", "tokenAddress", "assetFee"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return __typia_transform__assertGuard._assertGuard(_exceptionable, {
+        method: "createAssertEquals",
+        path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+        expected: "undefined",
+        value: value
+    }, _errorFactory);
+}))); const _ao7 = (input, _path, _exceptionable = true) => ("EVM_CALL" === input.type || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".type",
+    expected: "\"EVM_CALL\"",
+    value: input.type
+}, _errorFactory)) && ((null !== input.location || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".location",
+    expected: "(__type.o2 | __type.o5 | `chain:evm:${bigint}` | `chain:keeta:${bigint}`)",
+    value: input.location
+}, _errorFactory)) && (undefined !== input.location || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".location",
+    expected: "(__type.o2 | __type.o5 | `chain:evm:${bigint}` | `chain:keeta:${bigint}`)",
+    value: input.location
+}, _errorFactory)) && ("string" === typeof input.location && (RegExp(/^chain:keeta:[+-]?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/).test(input.location) || RegExp(/^chain:evm:[+-]?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/).test(input.location)) || ("object" === typeof input.location && null !== input.location || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".location",
+    expected: "(__type.o2 | __type.o5 | `chain:evm:${bigint}` | `chain:keeta:${bigint}`)",
+    value: input.location
+}, _errorFactory)) && _au1(input.location, _path + ".location", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".location",
+    expected: "(__type.o2 | __type.o5 | `chain:evm:${bigint}` | `chain:keeta:${bigint}`)",
+    value: input.location
+}, _errorFactory))) && ("string" === typeof input.contractAddress || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".contractAddress",
+    expected: "string",
+    value: input.contractAddress
+}, _errorFactory)) && ("string" === typeof input.contractMethodName || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".contractMethodName",
+    expected: "string",
+    value: input.contractMethodName
+}, _errorFactory)) && ((Array.isArray(input.contractMethodArgs) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".contractMethodArgs",
+    expected: "Array<string>",
+    value: input.contractMethodArgs
+}, _errorFactory)) && input.contractMethodArgs.every((elem, _index4) => "string" === typeof elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".contractMethodArgs[" + _index4 + "]",
+    expected: "string",
+    value: elem
+}, _errorFactory)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".contractMethodArgs",
+    expected: "Array<string>",
+    value: input.contractMethodArgs
+}, _errorFactory)) && ("string" === typeof input.assetFee || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".assetFee",
+    expected: "string",
+    value: input.assetFee
+}, _errorFactory)) && (6 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every(key => {
+    if (["type", "location", "contractAddress", "contractMethodName", "contractMethodArgs", "assetFee"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return __typia_transform__assertGuard._assertGuard(_exceptionable, {
+        method: "createAssertEquals",
+        path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+        expected: "undefined",
+        value: value
+    }, _errorFactory);
+}))); const _ao8 = (input, _path, _exceptionable = true) => (false === input.ok || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".ok",
+    expected: "false",
+    value: input.ok
+}, _errorFactory)) && ("string" === typeof input.error || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".error",
+    expected: "string",
+    value: input.error
+}, _errorFactory)) && (2 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every(key => {
+    if (["ok", "error"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return __typia_transform__assertGuard._assertGuard(_exceptionable, {
+        method: "createAssertEquals",
+        path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+        expected: "undefined",
+        value: value
+    }, _errorFactory);
+}))); const _au0 = (input, _path, _exceptionable = true) => (() => {
+    if ("KEETA_SEND" === input.type)
+        return _ao1(input, _path, true && _exceptionable);
+    else if ("EVM_SEND" === input.type)
+        return _ao6(input, _path, true && _exceptionable);
+    else if ("EVM_CALL" === input.type)
+        return _ao7(input, _path, true && _exceptionable);
+    else
+        return __typia_transform__assertGuard._assertGuard(_exceptionable, {
+            method: "createAssertEquals",
+            path: _path,
+            expected: "({ type: \"KEETA_SEND\"; location: AssetLocationLike; sendToAddress: string; value: string; tokenAddress: string; external?: string; } & { assetFee: string; } | { type: \"EVM_SEND\"; location: AssetLocationLike; sendToAddress: string; value: string; tokenAddress: `0x${string}`; } & { assetFee: string; } | { type: \"EVM_CALL\"; location: AssetLocationLike; contractAddress: string; contractMethodName: string; contractMethodArgs: string[]; } & { assetFee: string; })",
+            value: input
+        }, _errorFactory);
+})(); const _au1 = (input, _path, _exceptionable = true) => (() => {
+    if ("chain" === input.type)
+        return _ao2(input, _path, true && _exceptionable);
+    else if ("bank-account" === input.type)
+        return _ao5(input, _path, true && _exceptionable);
+    else
+        return __typia_transform__assertGuard._assertGuard(_exceptionable, {
+            method: "createAssertEquals",
+            path: _path,
+            expected: "(__type.o2 | __type.o5)",
+            value: input
+        }, _errorFactory);
+})(); const _au2 = (input, _path, _exceptionable = true) => (() => {
+    if ("keeta" === input.type)
+        return _ao3(input, _path, true && _exceptionable);
+    else if ("evm" === input.type)
+        return _ao4(input, _path, true && _exceptionable);
+    else
+        return __typia_transform__assertGuard._assertGuard(_exceptionable, {
+            method: "createAssertEquals",
+            path: _path,
+            expected: "(__type.o3 | __type.o4)",
+            value: input
+        }, _errorFactory);
+})(); const _au3 = (input, _path, _exceptionable = true) => (() => {
+    if (true === input.ok)
+        return _ao0(input, _path, true && _exceptionable);
+    else if (false === input.ok)
+        return _ao8(input, _path, true && _exceptionable);
+    else
+        return __typia_transform__assertGuard._assertGuard(_exceptionable, {
+            method: "createAssertEquals",
+            path: _path,
+            expected: "(__type | __type.o9)",
+            value: input
+        }, _errorFactory);
+})(); const __is = (input, _exceptionable = true) => "object" === typeof input && null !== input && _iu3(input, true); let _errorFactory; return (input, errorFactory) => {
+    if (false === __is(input)) {
+        _errorFactory = errorFactory;
+        ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || __typia_transform__assertGuard._assertGuard(true, {
+            method: "createAssertEquals",
+            path: _path + "",
+            expected: "(__type | __type.o9)",
+            value: input
+        }, _errorFactory)) && _au3(input, _path + "", true) || __typia_transform__assertGuard._assertGuard(true, {
+            method: "createAssertEquals",
+            path: _path + "",
+            expected: "(__type | __type.o9)",
+            value: input
+        }, _errorFactory))(input, "$input", true);
+    }
+    return input;
+}; })();
+export const assertKeetaAssetMovementAnchorGetTransferStatusRequest = (() => { const _io0 = input => "string" === typeof input.id; const _ao0 = (input, _path, _exceptionable = true) => "string" === typeof input.id || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".id",
+    expected: "string",
+    value: input.id
+}, _errorFactory); const __is = input => "object" === typeof input && null !== input && _io0(input); let _errorFactory; return (input, errorFactory) => {
+    if (false === __is(input)) {
+        _errorFactory = errorFactory;
+        ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || __typia_transform__assertGuard._assertGuard(true, {
+            method: "createAssert",
+            path: _path + "",
+            expected: "KeetaAssetMovementAnchorGetTransferStatusRequest",
+            value: input
+        }, _errorFactory)) && _ao0(input, _path + "", true) || __typia_transform__assertGuard._assertGuard(true, {
+            method: "createAssert",
+            path: _path + "",
+            expected: "KeetaAssetMovementAnchorGetTransferStatusRequest",
+            value: input
+        }, _errorFactory))(input, "$input", true);
+    }
+    return input;
+}; })();
+export const assertKeetaAssetMovementAnchorGetTransferStatusResponse = (() => { const _iv1 = new Set(["ALL", "AFN", "EUR", "DZD", "USD", "AOA", "XCD", "ARS", "AMD", "AWG", "AUD", "AZN", "BSD", "BHD", "BDT", "BBD", "BYN", "BZD", "XOF", "BMD", "INR", "BTN", "BOB", "BOV", "BAM", "BWP", "NOK", "BRL", "BND", "BGN", "BIF", "CVE", "KHR", "XAF", "CAD", "KYD", "CLP", "CLF", "CNY", "COP", "COU", "KMF", "CDF", "NZD", "CRC", "CUP", "CUC", "ANG", "CZK", "DKK", "DJF", "DOP", "EGP", "SVC", "ERN", "SZL", "ETB", "FKP", "FJD", "XPF", "GMD", "GEL", "GHS", "GIP", "GTQ", "GBP", "GNF", "GYD", "HTG", "HNL", "HKD", "HUF", "ISK", "IDR", "IRR", "IQD", "ILS", "JMD", "JPY", "JOD", "KZT", "KES", "KPW", "KRW", "KWD", "KGS", "LAK", "LBP", "LSL", "ZAR", "LRD", "LYD", "CHF", "MOP", "MKD", "MGA", "MWK", "MYR", "MVR", "MRU", "MUR", "MXN", "MXV", "MDL", "MNT", "MAD", "MZN", "MMK", "NAD", "NPR", "NIO", "NGN", "OMR", "PKR", "PAB", "PGK", "PYG", "PEN", "PHP", "PLN", "QAR", "RON", "RUB", "RWF", "SHP", "WST", "STN", "SAR", "RSD", "SCR", "SLL", "SLE", "SGD", "SBD", "SOS", "SSP", "LKR", "SDG", "SRD", "SEK", "CHE", "CHW", "SYP", "TWD", "TJS", "TZS", "THB", "TOP", "TTD", "TND", "TRY", "TMT", "UGX", "UAH", "AED", "USN", "UYU", "UYI", "UYW", "UZS", "VUV", "VES", "VED", "VND", "YER", "ZMW", "ZWL"]); const _iv2 = new Set(["971", "978", "8", "12", "840", "973", "951", "32", "51", "533", "36", "944", "44", "48", "50", "52", "933", "84", "952", "60", "356", "64", "68", "984", "977", "72", "578", "986", "96", "975", "108", "132", "116", "950", "124", "136", "152", "990", "156", "170", "970", "174", "976", "554", "188", "192", "931", "532", "203", "208", "262", "214", "818", "222", "232", "748", "230", "238", "242", "953", "270", "981", "936", "292", "320", "826", "324", "328", "332", "340", "344", "348", "352", "360", "364", "368", "376", "388", "392", "400", "398", "404", "408", "410", "414", "417", "418", "422", "426", "710", "430", "434", "756", "446", "807", "969", "454", "458", "462", "929", "480", "484", "979", "498", "496", "504", "943", "104", "516", "524", "558", "566", "512", "586", "590", "598", "600", "604", "608", "985", "634", "946", "643", "646", "654", "882", "930", "682", "941", "690", "694", "925", "702", "90", "706", "728", "144", "938", "968", "752", "947", "948", "760", "901", "972", "834", "764", "776", "780", "788", "949", "934", "800", "980", "784", "997", "858", "940", "927", "860", "548", "928", "926", "704", "886", "967", "932"]); const _av3 = new Set(["ALL", "AFN", "EUR", "DZD", "USD", "AOA", "XCD", "ARS", "AMD", "AWG", "AUD", "AZN", "BSD", "BHD", "BDT", "BBD", "BYN", "BZD", "XOF", "BMD", "INR", "BTN", "BOB", "BOV", "BAM", "BWP", "NOK", "BRL", "BND", "BGN", "BIF", "CVE", "KHR", "XAF", "CAD", "KYD", "CLP", "CLF", "CNY", "COP", "COU", "KMF", "CDF", "NZD", "CRC", "CUP", "CUC", "ANG", "CZK", "DKK", "DJF", "DOP", "EGP", "SVC", "ERN", "SZL", "ETB", "FKP", "FJD", "XPF", "GMD", "GEL", "GHS", "GIP", "GTQ", "GBP", "GNF", "GYD", "HTG", "HNL", "HKD", "HUF", "ISK", "IDR", "IRR", "IQD", "ILS", "JMD", "JPY", "JOD", "KZT", "KES", "KPW", "KRW", "KWD", "KGS", "LAK", "LBP", "LSL", "ZAR", "LRD", "LYD", "CHF", "MOP", "MKD", "MGA", "MWK", "MYR", "MVR", "MRU", "MUR", "MXN", "MXV", "MDL", "MNT", "MAD", "MZN", "MMK", "NAD", "NPR", "NIO", "NGN", "OMR", "PKR", "PAB", "PGK", "PYG", "PEN", "PHP", "PLN", "QAR", "RON", "RUB", "RWF", "SHP", "WST", "STN", "SAR", "RSD", "SCR", "SLL", "SLE", "SGD", "SBD", "SOS", "SSP", "LKR", "SDG", "SRD", "SEK", "CHE", "CHW", "SYP", "TWD", "TJS", "TZS", "THB", "TOP", "TTD", "TND", "TRY", "TMT", "UGX", "UAH", "AED", "USN", "UYU", "UYI", "UYW", "UZS", "VUV", "VES", "VED", "VND", "YER", "ZMW", "ZWL"]); const _av4 = new Set(["971", "978", "8", "12", "840", "973", "951", "32", "51", "533", "36", "944", "44", "48", "50", "52", "933", "84", "952", "60", "356", "64", "68", "984", "977", "72", "578", "986", "96", "975", "108", "132", "116", "950", "124", "136", "152", "990", "156", "170", "970", "174", "976", "554", "188", "192", "931", "532", "203", "208", "262", "214", "818", "222", "232", "748", "230", "238", "242", "953", "270", "981", "936", "292", "320", "826", "324", "328", "332", "340", "344", "348", "352", "360", "364", "368", "376", "388", "392", "400", "398", "404", "408", "410", "414", "417", "418", "422", "426", "710", "430", "434", "756", "446", "807", "969", "454", "458", "462", "929", "480", "484", "979", "498", "496", "504", "943", "104", "516", "524", "558", "566", "512", "586", "590", "598", "600", "604", "608", "985", "634", "946", "643", "646", "654", "882", "930", "682", "941", "690", "694", "925", "702", "90", "706", "728", "144", "938", "968", "752", "947", "948", "760", "901", "972", "834", "764", "776", "780", "788", "949", "934", "800", "980", "784", "997", "858", "940", "927", "860", "548", "928", "926", "704", "886", "967", "932"]); const _io0 = (input, _exceptionable = true) => true === input.ok && ("object" === typeof input.transaction && null !== input.transaction && _io1(input.transaction, true && _exceptionable)) && (2 === Object.keys(input).length || Object.keys(input).every(key => {
+    if (["ok", "transaction"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return false;
+})); const _io1 = (input, _exceptionable = true) => "string" === typeof input.id && "string" === typeof input.status && (null !== input.asset && undefined !== input.asset && ("string" === typeof input.asset && (RegExp(/^keeta_am(.*)/).test(input.asset) || RegExp(/^keeta_an(.*)/).test(input.asset) || RegExp(/^keeta_ao(.*)/).test(input.asset) || RegExp(/^keeta_ap(.*)/).test(input.asset) || RegExp(/^tyblocks_am(.*)/).test(input.asset) || RegExp(/^tyblocks_an(.*)/).test(input.asset) || RegExp(/^tyblocks_ao(.*)/).test(input.asset) || RegExp(/^tyblocks_ap(.*)/).test(input.asset)) || "object" === typeof input.asset && null !== input.asset && _iu0(input.asset, true && _exceptionable))) && ("object" === typeof input.from && null !== input.from && _io4(input.from, true && _exceptionable)) && ("object" === typeof input.to && null !== input.to && _io7(input.to, true && _exceptionable)) && (null === input.fee || "object" === typeof input.fee && null !== input.fee && _io9(input.fee, true && _exceptionable)) && "string" === typeof input.createdAt && "string" === typeof input.updatedAt && (8 === Object.keys(input).length || Object.keys(input).every(key => {
+    if (["id", "status", "asset", "from", "to", "fee", "createdAt", "updatedAt"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return false;
+})); const _io2 = (input, _exceptionable = true) => true && true === _iv1.has(input.code) && "string" === typeof input.name && "string" === typeof input.precision && true === _iv2.has(input.isoNumber) && (5 === Object.keys(input).length || Object.keys(input).every(key => {
+    if (["#private", "code", "name", "precision", "isoNumber"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return false;
+})); const _io3 = (input, _exceptionable = true) => true && (1 === Object.keys(input).length || Object.keys(input).every(key => {
+    if (["#private"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return false;
+})); const _io4 = (input, _exceptionable = true) => "string" === typeof input.location && (RegExp(/^chain:keeta:[+-]?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/).test(input.location) || RegExp(/^chain:evm:[+-]?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/).test(input.location)) && "string" === typeof input.value && ("object" === typeof input.transactions && null !== input.transactions && _io5(input.transactions, true && _exceptionable)) && (3 === Object.keys(input).length || Object.keys(input).every(key => {
+    if (["location", "value", "transactions"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return false;
+})); const _io5 = (input, _exceptionable = true) => (null === input.persistentForwarding || "object" === typeof input.persistentForwarding && null !== input.persistentForwarding && _io6(input.persistentForwarding, true && _exceptionable)) && (null === input.deposit || "object" === typeof input.deposit && null !== input.deposit && _io6(input.deposit, true && _exceptionable)) && (null === input.finalization || "object" === typeof input.finalization && null !== input.finalization && _io6(input.finalization, true && _exceptionable)) && (3 === Object.keys(input).length || Object.keys(input).every(key => {
+    if (["persistentForwarding", "deposit", "finalization"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return false;
+})); const _io6 = (input, _exceptionable = true) => "string" === typeof input.id && "string" === typeof input.nonce && (2 === Object.keys(input).length || Object.keys(input).every(key => {
+    if (["id", "nonce"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return false;
+})); const _io7 = (input, _exceptionable = true) => "string" === typeof input.location && (RegExp(/^chain:keeta:[+-]?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/).test(input.location) || RegExp(/^chain:evm:[+-]?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/).test(input.location)) && "string" === typeof input.value && ("object" === typeof input.transactions && null !== input.transactions && _io8(input.transactions, true && _exceptionable)) && (3 === Object.keys(input).length || Object.keys(input).every(key => {
+    if (["location", "value", "transactions"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return false;
+})); const _io8 = (input, _exceptionable = true) => (null === input.withdraw || "object" === typeof input.withdraw && null !== input.withdraw && _io6(input.withdraw, true && _exceptionable)) && (1 === Object.keys(input).length || Object.keys(input).every(key => {
+    if (["withdraw"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return false;
+})); const _io9 = (input, _exceptionable = true) => null !== input.asset && undefined !== input.asset && ("string" === typeof input.asset && (RegExp(/^keeta_am(.*)/).test(input.asset) || RegExp(/^keeta_an(.*)/).test(input.asset) || RegExp(/^keeta_ao(.*)/).test(input.asset) || RegExp(/^keeta_ap(.*)/).test(input.asset) || RegExp(/^tyblocks_am(.*)/).test(input.asset) || RegExp(/^tyblocks_an(.*)/).test(input.asset) || RegExp(/^tyblocks_ao(.*)/).test(input.asset) || RegExp(/^tyblocks_ap(.*)/).test(input.asset)) || "object" === typeof input.asset && null !== input.asset && _iu0(input.asset, true && _exceptionable)) && "string" === typeof input.value && (2 === Object.keys(input).length || Object.keys(input).every(key => {
+    if (["asset", "value"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return false;
+})); const _io10 = (input, _exceptionable = true) => false === input.ok && "string" === typeof input.error && (2 === Object.keys(input).length || Object.keys(input).every(key => {
+    if (["ok", "error"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return false;
+})); const _iu0 = (input, _exceptionable = true) => (() => {
+    if (undefined !== input.code)
+        return _io2(input, true && _exceptionable);
+    else
+        return _io3(input, true && _exceptionable);
+})(); const _iu1 = (input, _exceptionable = true) => (() => {
+    if (true === input.ok)
+        return _io0(input, true && _exceptionable);
+    else if (false === input.ok)
+        return _io10(input, true && _exceptionable);
+    else
+        return false;
+})(); const _ao0 = (input, _path, _exceptionable = true) => (true === input.ok || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".ok",
+    expected: "true",
+    value: input.ok
+}, _errorFactory)) && (("object" === typeof input.transaction && null !== input.transaction || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".transaction",
+    expected: "KeetaAssetMovementTransaction",
+    value: input.transaction
+}, _errorFactory)) && _ao1(input.transaction, _path + ".transaction", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".transaction",
+    expected: "KeetaAssetMovementTransaction",
+    value: input.transaction
+}, _errorFactory)) && (2 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every(key => {
+    if (["ok", "transaction"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return __typia_transform__assertGuard._assertGuard(_exceptionable, {
+        method: "createAssertEquals",
+        path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+        expected: "undefined",
+        value: value
+    }, _errorFactory);
+}))); const _ao1 = (input, _path, _exceptionable = true) => ("string" === typeof input.id || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".id",
+    expected: "string",
+    value: input.id
+}, _errorFactory)) && ("string" === typeof input.status || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".status",
+    expected: "string",
+    value: input.status
+}, _errorFactory)) && ((null !== input.asset || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".asset",
+    expected: "(Currency | TokenAddress | `keeta_am${string}` | `keeta_an${string}` | `keeta_ao${string}` | `keeta_ap${string}` | `tyblocks_am${string}` | `tyblocks_an${string}` | `tyblocks_ao${string}` | `tyblocks_ap${string}`)",
+    value: input.asset
+}, _errorFactory)) && (undefined !== input.asset || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".asset",
+    expected: "(Currency | TokenAddress | `keeta_am${string}` | `keeta_an${string}` | `keeta_ao${string}` | `keeta_ap${string}` | `tyblocks_am${string}` | `tyblocks_an${string}` | `tyblocks_ao${string}` | `tyblocks_ap${string}`)",
+    value: input.asset
+}, _errorFactory)) && ("string" === typeof input.asset && (RegExp(/^keeta_am(.*)/).test(input.asset) || RegExp(/^keeta_an(.*)/).test(input.asset) || RegExp(/^keeta_ao(.*)/).test(input.asset) || RegExp(/^keeta_ap(.*)/).test(input.asset) || RegExp(/^tyblocks_am(.*)/).test(input.asset) || RegExp(/^tyblocks_an(.*)/).test(input.asset) || RegExp(/^tyblocks_ao(.*)/).test(input.asset) || RegExp(/^tyblocks_ap(.*)/).test(input.asset)) || ("object" === typeof input.asset && null !== input.asset || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".asset",
+    expected: "(Currency | TokenAddress | `keeta_am${string}` | `keeta_an${string}` | `keeta_ao${string}` | `keeta_ap${string}` | `tyblocks_am${string}` | `tyblocks_an${string}` | `tyblocks_ao${string}` | `tyblocks_ap${string}`)",
+    value: input.asset
+}, _errorFactory)) && _au0(input.asset, _path + ".asset", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".asset",
+    expected: "(Currency | TokenAddress | `keeta_am${string}` | `keeta_an${string}` | `keeta_ao${string}` | `keeta_ap${string}` | `tyblocks_am${string}` | `tyblocks_an${string}` | `tyblocks_ao${string}` | `tyblocks_ap${string}`)",
+    value: input.asset
+}, _errorFactory))) && (("object" === typeof input.from && null !== input.from || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".from",
+    expected: "__type.o1",
+    value: input.from
+}, _errorFactory)) && _ao4(input.from, _path + ".from", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".from",
+    expected: "__type.o1",
+    value: input.from
+}, _errorFactory)) && (("object" === typeof input.to && null !== input.to || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".to",
+    expected: "__type.o2",
+    value: input.to
+}, _errorFactory)) && _ao7(input.to, _path + ".to", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".to",
+    expected: "__type.o2",
+    value: input.to
+}, _errorFactory)) && (null === input.fee || ("object" === typeof input.fee && null !== input.fee || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".fee",
+    expected: "(__type.o3 | null)",
+    value: input.fee
+}, _errorFactory)) && _ao9(input.fee, _path + ".fee", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".fee",
+    expected: "(__type.o3 | null)",
+    value: input.fee
+}, _errorFactory)) && ("string" === typeof input.createdAt || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".createdAt",
+    expected: "string",
+    value: input.createdAt
+}, _errorFactory)) && ("string" === typeof input.updatedAt || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".updatedAt",
+    expected: "string",
+    value: input.updatedAt
+}, _errorFactory)) && (8 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every(key => {
+    if (["id", "status", "asset", "from", "to", "fee", "createdAt", "updatedAt"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return __typia_transform__assertGuard._assertGuard(_exceptionable, {
+        method: "createAssertEquals",
+        path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+        expected: "undefined",
+        value: value
+    }, _errorFactory);
+}))); const _ao2 = (input, _path, _exceptionable = true) => true && (true === _av3.has(input.code) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".code",
+    expected: "(\"AED\" | \"AFN\" | \"ALL\" | \"AMD\" | \"ANG\" | \"AOA\" | \"ARS\" | \"AUD\" | \"AWG\" | \"AZN\" | \"BAM\" | \"BBD\" | \"BDT\" | \"BGN\" | \"BHD\" | \"BIF\" | \"BMD\" | \"BND\" | \"BOB\" | \"BOV\" | \"BRL\" | \"BSD\" | \"BTN\" | \"BWP\" | \"BYN\" | \"BZD\" | \"CAD\" | \"CDF\" | \"CHE\" | \"CHF\" | \"CHW\" | \"CLF\" | \"CLP\" | \"CNY\" | \"COP\" | \"COU\" | \"CRC\" | \"CUC\" | \"CUP\" | \"CVE\" | \"CZK\" | \"DJF\" | \"DKK\" | \"DOP\" | \"DZD\" | \"EGP\" | \"ERN\" | \"ETB\" | \"EUR\" | \"FJD\" | \"FKP\" | \"GBP\" | \"GEL\" | \"GHS\" | \"GIP\" | \"GMD\" | \"GNF\" | \"GTQ\" | \"GYD\" | \"HKD\" | \"HNL\" | \"HTG\" | \"HUF\" | \"IDR\" | \"ILS\" | \"INR\" | \"IQD\" | \"IRR\" | \"ISK\" | \"JMD\" | \"JOD\" | \"JPY\" | \"KES\" | \"KGS\" | \"KHR\" | \"KMF\" | \"KPW\" | \"KRW\" | \"KWD\" | \"KYD\" | \"KZT\" | \"LAK\" | \"LBP\" | \"LKR\" | \"LRD\" | \"LSL\" | \"LYD\" | \"MAD\" | \"MDL\" | \"MGA\" | \"MKD\" | \"MMK\" | \"MNT\" | \"MOP\" | \"MRU\" | \"MUR\" | \"MVR\" | \"MWK\" | \"MXN\" | \"MXV\" | \"MYR\" | \"MZN\" | \"NAD\" | \"NGN\" | \"NIO\" | \"NOK\" | \"NPR\" | \"NZD\" | \"OMR\" | \"PAB\" | \"PEN\" | \"PGK\" | \"PHP\" | \"PKR\" | \"PLN\" | \"PYG\" | \"QAR\" | \"RON\" | \"RSD\" | \"RUB\" | \"RWF\" | \"SAR\" | \"SBD\" | \"SCR\" | \"SDG\" | \"SEK\" | \"SGD\" | \"SHP\" | \"SLE\" | \"SLL\" | \"SOS\" | \"SRD\" | \"SSP\" | \"STN\" | \"SVC\" | \"SYP\" | \"SZL\" | \"THB\" | \"TJS\" | \"TMT\" | \"TND\" | \"TOP\" | \"TRY\" | \"TTD\" | \"TWD\" | \"TZS\" | \"UAH\" | \"UGX\" | \"USD\" | \"USN\" | \"UYI\" | \"UYU\" | \"UYW\" | \"UZS\" | \"VED\" | \"VES\" | \"VND\" | \"VUV\" | \"WST\" | \"XAF\" | \"XCD\" | \"XOF\" | \"XPF\" | \"YER\" | \"ZAR\" | \"ZMW\" | \"ZWL\")",
+    value: input.code
+}, _errorFactory)) && ("string" === typeof input.name || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".name",
+    expected: "string",
+    value: input.name
+}, _errorFactory)) && ("string" === typeof input.precision || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".precision",
+    expected: "string",
+    value: input.precision
+}, _errorFactory)) && (true === _av4.has(input.isoNumber) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".isoNumber",
+    expected: "(\"104\" | \"108\" | \"116\" | \"12\" | \"124\" | \"132\" | \"136\" | \"144\" | \"152\" | \"156\" | \"170\" | \"174\" | \"188\" | \"192\" | \"203\" | \"208\" | \"214\" | \"222\" | \"230\" | \"232\" | \"238\" | \"242\" | \"262\" | \"270\" | \"292\" | \"32\" | \"320\" | \"324\" | \"328\" | \"332\" | \"340\" | \"344\" | \"348\" | \"352\" | \"356\" | \"36\" | \"360\" | \"364\" | \"368\" | \"376\" | \"388\" | \"392\" | \"398\" | \"400\" | \"404\" | \"408\" | \"410\" | \"414\" | \"417\" | \"418\" | \"422\" | \"426\" | \"430\" | \"434\" | \"44\" | \"446\" | \"454\" | \"458\" | \"462\" | \"48\" | \"480\" | \"484\" | \"496\" | \"498\" | \"50\" | \"504\" | \"51\" | \"512\" | \"516\" | \"52\" | \"524\" | \"532\" | \"533\" | \"548\" | \"554\" | \"558\" | \"566\" | \"578\" | \"586\" | \"590\" | \"598\" | \"60\" | \"600\" | \"604\" | \"608\" | \"634\" | \"64\" | \"643\" | \"646\" | \"654\" | \"68\" | \"682\" | \"690\" | \"694\" | \"702\" | \"704\" | \"706\" | \"710\" | \"72\" | \"728\" | \"748\" | \"752\" | \"756\" | \"760\" | \"764\" | \"776\" | \"780\" | \"784\" | \"788\" | \"8\" | \"800\" | \"807\" | \"818\" | \"826\" | \"834\" | \"84\" | \"840\" | \"858\" | \"860\" | \"882\" | \"886\" | \"90\" | \"901\" | \"925\" | \"926\" | \"927\" | \"928\" | \"929\" | \"930\" | \"931\" | \"932\" | \"933\" | \"934\" | \"936\" | \"938\" | \"940\" | \"941\" | \"943\" | \"944\" | \"946\" | \"947\" | \"948\" | \"949\" | \"950\" | \"951\" | \"952\" | \"953\" | \"96\" | \"967\" | \"968\" | \"969\" | \"970\" | \"971\" | \"972\" | \"973\" | \"975\" | \"976\" | \"977\" | \"978\" | \"979\" | \"980\" | \"981\" | \"984\" | \"985\" | \"986\" | \"990\" | \"997\")",
+    value: input.isoNumber
+}, _errorFactory)) && (5 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every(key => {
+    if (["#private", "code", "name", "precision", "isoNumber"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return __typia_transform__assertGuard._assertGuard(_exceptionable, {
+        method: "createAssertEquals",
+        path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+        expected: "undefined",
+        value: value
+    }, _errorFactory);
+}))); const _ao3 = (input, _path, _exceptionable = true) => true && (1 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every(key => {
+    if (["#private"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return __typia_transform__assertGuard._assertGuard(_exceptionable, {
+        method: "createAssertEquals",
+        path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+        expected: "undefined",
+        value: value
+    }, _errorFactory);
+}))); const _ao4 = (input, _path, _exceptionable = true) => ("string" === typeof input.location && (RegExp(/^chain:keeta:[+-]?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/).test(input.location) || RegExp(/^chain:evm:[+-]?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/).test(input.location)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".location",
+    expected: "(`chain:evm:${bigint}` | `chain:keeta:${bigint}`)",
+    value: input.location
+}, _errorFactory)) && ("string" === typeof input.value || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".value",
+    expected: "string",
+    value: input.value
+}, _errorFactory)) && (("object" === typeof input.transactions && null !== input.transactions || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".transactions",
+    expected: "TransactionIds<\"persistentForwarding\" | \"deposit\" | \"finalization\">",
+    value: input.transactions
+}, _errorFactory)) && _ao5(input.transactions, _path + ".transactions", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".transactions",
+    expected: "TransactionIds<\"persistentForwarding\" | \"deposit\" | \"finalization\">",
+    value: input.transactions
+}, _errorFactory)) && (3 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every(key => {
+    if (["location", "value", "transactions"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return __typia_transform__assertGuard._assertGuard(_exceptionable, {
+        method: "createAssertEquals",
+        path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+        expected: "undefined",
+        value: value
+    }, _errorFactory);
+}))); const _ao5 = (input, _path, _exceptionable = true) => (null === input.persistentForwarding || ("object" === typeof input.persistentForwarding && null !== input.persistentForwarding || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".persistentForwarding",
+    expected: "(TransactionId | null)",
+    value: input.persistentForwarding
+}, _errorFactory)) && _ao6(input.persistentForwarding, _path + ".persistentForwarding", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".persistentForwarding",
+    expected: "(TransactionId | null)",
+    value: input.persistentForwarding
+}, _errorFactory)) && (null === input.deposit || ("object" === typeof input.deposit && null !== input.deposit || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".deposit",
+    expected: "(TransactionId | null)",
+    value: input.deposit
+}, _errorFactory)) && _ao6(input.deposit, _path + ".deposit", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".deposit",
+    expected: "(TransactionId | null)",
+    value: input.deposit
+}, _errorFactory)) && (null === input.finalization || ("object" === typeof input.finalization && null !== input.finalization || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".finalization",
+    expected: "(TransactionId | null)",
+    value: input.finalization
+}, _errorFactory)) && _ao6(input.finalization, _path + ".finalization", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".finalization",
+    expected: "(TransactionId | null)",
+    value: input.finalization
+}, _errorFactory)) && (3 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every(key => {
+    if (["persistentForwarding", "deposit", "finalization"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return __typia_transform__assertGuard._assertGuard(_exceptionable, {
+        method: "createAssertEquals",
+        path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+        expected: "undefined",
+        value: value
+    }, _errorFactory);
+}))); const _ao6 = (input, _path, _exceptionable = true) => ("string" === typeof input.id || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".id",
+    expected: "string",
+    value: input.id
+}, _errorFactory)) && ("string" === typeof input.nonce || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".nonce",
+    expected: "string",
+    value: input.nonce
+}, _errorFactory)) && (2 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every(key => {
+    if (["id", "nonce"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return __typia_transform__assertGuard._assertGuard(_exceptionable, {
+        method: "createAssertEquals",
+        path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+        expected: "undefined",
+        value: value
+    }, _errorFactory);
+}))); const _ao7 = (input, _path, _exceptionable = true) => ("string" === typeof input.location && (RegExp(/^chain:keeta:[+-]?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/).test(input.location) || RegExp(/^chain:evm:[+-]?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/).test(input.location)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".location",
+    expected: "(`chain:evm:${bigint}` | `chain:keeta:${bigint}`)",
+    value: input.location
+}, _errorFactory)) && ("string" === typeof input.value || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".value",
+    expected: "string",
+    value: input.value
+}, _errorFactory)) && (("object" === typeof input.transactions && null !== input.transactions || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".transactions",
+    expected: "TransactionIds<\"withdraw\">",
+    value: input.transactions
+}, _errorFactory)) && _ao8(input.transactions, _path + ".transactions", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".transactions",
+    expected: "TransactionIds<\"withdraw\">",
+    value: input.transactions
+}, _errorFactory)) && (3 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every(key => {
+    if (["location", "value", "transactions"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return __typia_transform__assertGuard._assertGuard(_exceptionable, {
+        method: "createAssertEquals",
+        path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+        expected: "undefined",
+        value: value
+    }, _errorFactory);
+}))); const _ao8 = (input, _path, _exceptionable = true) => (null === input.withdraw || ("object" === typeof input.withdraw && null !== input.withdraw || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".withdraw",
+    expected: "(TransactionId | null)",
+    value: input.withdraw
+}, _errorFactory)) && _ao6(input.withdraw, _path + ".withdraw", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".withdraw",
+    expected: "(TransactionId | null)",
+    value: input.withdraw
+}, _errorFactory)) && (1 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every(key => {
+    if (["withdraw"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return __typia_transform__assertGuard._assertGuard(_exceptionable, {
+        method: "createAssertEquals",
+        path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+        expected: "undefined",
+        value: value
+    }, _errorFactory);
+}))); const _ao9 = (input, _path, _exceptionable = true) => (null !== input.asset || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".asset",
+    expected: "(Currency | TokenAddress | `keeta_am${string}` | `keeta_an${string}` | `keeta_ao${string}` | `keeta_ap${string}` | `tyblocks_am${string}` | `tyblocks_an${string}` | `tyblocks_ao${string}` | `tyblocks_ap${string}`)",
+    value: input.asset
+}, _errorFactory)) && (undefined !== input.asset || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".asset",
+    expected: "(Currency | TokenAddress | `keeta_am${string}` | `keeta_an${string}` | `keeta_ao${string}` | `keeta_ap${string}` | `tyblocks_am${string}` | `tyblocks_an${string}` | `tyblocks_ao${string}` | `tyblocks_ap${string}`)",
+    value: input.asset
+}, _errorFactory)) && ("string" === typeof input.asset && (RegExp(/^keeta_am(.*)/).test(input.asset) || RegExp(/^keeta_an(.*)/).test(input.asset) || RegExp(/^keeta_ao(.*)/).test(input.asset) || RegExp(/^keeta_ap(.*)/).test(input.asset) || RegExp(/^tyblocks_am(.*)/).test(input.asset) || RegExp(/^tyblocks_an(.*)/).test(input.asset) || RegExp(/^tyblocks_ao(.*)/).test(input.asset) || RegExp(/^tyblocks_ap(.*)/).test(input.asset)) || ("object" === typeof input.asset && null !== input.asset || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".asset",
+    expected: "(Currency | TokenAddress | `keeta_am${string}` | `keeta_an${string}` | `keeta_ao${string}` | `keeta_ap${string}` | `tyblocks_am${string}` | `tyblocks_an${string}` | `tyblocks_ao${string}` | `tyblocks_ap${string}`)",
+    value: input.asset
+}, _errorFactory)) && _au0(input.asset, _path + ".asset", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".asset",
+    expected: "(Currency | TokenAddress | `keeta_am${string}` | `keeta_an${string}` | `keeta_ao${string}` | `keeta_ap${string}` | `tyblocks_am${string}` | `tyblocks_an${string}` | `tyblocks_ao${string}` | `tyblocks_ap${string}`)",
+    value: input.asset
+}, _errorFactory)) && ("string" === typeof input.value || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".value",
+    expected: "string",
+    value: input.value
+}, _errorFactory)) && (2 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every(key => {
+    if (["asset", "value"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return __typia_transform__assertGuard._assertGuard(_exceptionable, {
+        method: "createAssertEquals",
+        path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+        expected: "undefined",
+        value: value
+    }, _errorFactory);
+}))); const _ao10 = (input, _path, _exceptionable = true) => (false === input.ok || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".ok",
+    expected: "false",
+    value: input.ok
+}, _errorFactory)) && ("string" === typeof input.error || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".error",
+    expected: "string",
+    value: input.error
+}, _errorFactory)) && (2 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every(key => {
+    if (["ok", "error"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return __typia_transform__assertGuard._assertGuard(_exceptionable, {
+        method: "createAssertEquals",
+        path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+        expected: "undefined",
+        value: value
+    }, _errorFactory);
+}))); const _au0 = (input, _path, _exceptionable = true) => (() => {
+    if (undefined !== input.code)
+        return _ao2(input, _path, true && _exceptionable);
+    else
+        return _ao3(input, _path, true && _exceptionable);
+})(); const _au1 = (input, _path, _exceptionable = true) => (() => {
+    if (true === input.ok)
+        return _ao0(input, _path, true && _exceptionable);
+    else if (false === input.ok)
+        return _ao10(input, _path, true && _exceptionable);
+    else
+        return __typia_transform__assertGuard._assertGuard(_exceptionable, {
+            method: "createAssertEquals",
+            path: _path,
+            expected: "(__type | __type.o4)",
+            value: input
+        }, _errorFactory);
+})(); const __is = (input, _exceptionable = true) => "object" === typeof input && null !== input && _iu1(input, true); let _errorFactory; return (input, errorFactory) => {
+    if (false === __is(input)) {
+        _errorFactory = errorFactory;
+        ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || __typia_transform__assertGuard._assertGuard(true, {
+            method: "createAssertEquals",
+            path: _path + "",
+            expected: "(__type | __type.o4)",
+            value: input
+        }, _errorFactory)) && _au1(input, _path + "", true) || __typia_transform__assertGuard._assertGuard(true, {
+            method: "createAssertEquals",
+            path: _path + "",
+            expected: "(__type | __type.o4)",
+            value: input
+        }, _errorFactory))(input, "$input", true);
+    }
+    return input;
+}; })();
+export const assertKeetaAssetMovementAnchorlistTransactionsRequest = (() => { const _iv2 = new Set(["ALL", "AFN", "EUR", "DZD", "USD", "AOA", "XCD", "ARS", "AMD", "AWG", "AUD", "AZN", "BSD", "BHD", "BDT", "BBD", "BYN", "BZD", "XOF", "BMD", "INR", "BTN", "BOB", "BOV", "BAM", "BWP", "NOK", "BRL", "BND", "BGN", "BIF", "CVE", "KHR", "XAF", "CAD", "KYD", "CLP", "CLF", "CNY", "COP", "COU", "KMF", "CDF", "NZD", "CRC", "CUP", "CUC", "ANG", "CZK", "DKK", "DJF", "DOP", "EGP", "SVC", "ERN", "SZL", "ETB", "FKP", "FJD", "XPF", "GMD", "GEL", "GHS", "GIP", "GTQ", "GBP", "GNF", "GYD", "HTG", "HNL", "HKD", "HUF", "ISK", "IDR", "IRR", "IQD", "ILS", "JMD", "JPY", "JOD", "KZT", "KES", "KPW", "KRW", "KWD", "KGS", "LAK", "LBP", "LSL", "ZAR", "LRD", "LYD", "CHF", "MOP", "MKD", "MGA", "MWK", "MYR", "MVR", "MRU", "MUR", "MXN", "MXV", "MDL", "MNT", "MAD", "MZN", "MMK", "NAD", "NPR", "NIO", "NGN", "OMR", "PKR", "PAB", "PGK", "PYG", "PEN", "PHP", "PLN", "QAR", "RON", "RUB", "RWF", "SHP", "WST", "STN", "SAR", "RSD", "SCR", "SLL", "SLE", "SGD", "SBD", "SOS", "SSP", "LKR", "SDG", "SRD", "SEK", "CHE", "CHW", "SYP", "TWD", "TJS", "TZS", "THB", "TOP", "TTD", "TND", "TRY", "TMT", "UGX", "UAH", "AED", "USN", "UYU", "UYI", "UYW", "UZS", "VUV", "VES", "VED", "VND", "YER", "ZMW", "ZWL"]); const _iv3 = new Set(["971", "978", "8", "12", "840", "973", "951", "32", "51", "533", "36", "944", "44", "48", "50", "52", "933", "84", "952", "60", "356", "64", "68", "984", "977", "72", "578", "986", "96", "975", "108", "132", "116", "950", "124", "136", "152", "990", "156", "170", "970", "174", "976", "554", "188", "192", "931", "532", "203", "208", "262", "214", "818", "222", "232", "748", "230", "238", "242", "953", "270", "981", "936", "292", "320", "826", "324", "328", "332", "340", "344", "348", "352", "360", "364", "368", "376", "388", "392", "400", "398", "404", "408", "410", "414", "417", "418", "422", "426", "710", "430", "434", "756", "446", "807", "969", "454", "458", "462", "929", "480", "484", "979", "498", "496", "504", "943", "104", "516", "524", "558", "566", "512", "586", "590", "598", "600", "604", "608", "985", "634", "946", "643", "646", "654", "882", "930", "682", "941", "690", "694", "925", "702", "90", "706", "728", "144", "938", "968", "752", "947", "948", "760", "901", "972", "834", "764", "776", "780", "788", "949", "934", "800", "980", "784", "997", "858", "940", "927", "860", "548", "928", "926", "704", "886", "967", "932"]); const _av5 = new Set(["ALL", "AFN", "EUR", "DZD", "USD", "AOA", "XCD", "ARS", "AMD", "AWG", "AUD", "AZN", "BSD", "BHD", "BDT", "BBD", "BYN", "BZD", "XOF", "BMD", "INR", "BTN", "BOB", "BOV", "BAM", "BWP", "NOK", "BRL", "BND", "BGN", "BIF", "CVE", "KHR", "XAF", "CAD", "KYD", "CLP", "CLF", "CNY", "COP", "COU", "KMF", "CDF", "NZD", "CRC", "CUP", "CUC", "ANG", "CZK", "DKK", "DJF", "DOP", "EGP", "SVC", "ERN", "SZL", "ETB", "FKP", "FJD", "XPF", "GMD", "GEL", "GHS", "GIP", "GTQ", "GBP", "GNF", "GYD", "HTG", "HNL", "HKD", "HUF", "ISK", "IDR", "IRR", "IQD", "ILS", "JMD", "JPY", "JOD", "KZT", "KES", "KPW", "KRW", "KWD", "KGS", "LAK", "LBP", "LSL", "ZAR", "LRD", "LYD", "CHF", "MOP", "MKD", "MGA", "MWK", "MYR", "MVR", "MRU", "MUR", "MXN", "MXV", "MDL", "MNT", "MAD", "MZN", "MMK", "NAD", "NPR", "NIO", "NGN", "OMR", "PKR", "PAB", "PGK", "PYG", "PEN", "PHP", "PLN", "QAR", "RON", "RUB", "RWF", "SHP", "WST", "STN", "SAR", "RSD", "SCR", "SLL", "SLE", "SGD", "SBD", "SOS", "SSP", "LKR", "SDG", "SRD", "SEK", "CHE", "CHW", "SYP", "TWD", "TJS", "TZS", "THB", "TOP", "TTD", "TND", "TRY", "TMT", "UGX", "UAH", "AED", "USN", "UYU", "UYI", "UYW", "UZS", "VUV", "VES", "VED", "VND", "YER", "ZMW", "ZWL"]); const _av6 = new Set(["971", "978", "8", "12", "840", "973", "951", "32", "51", "533", "36", "944", "44", "48", "50", "52", "933", "84", "952", "60", "356", "64", "68", "984", "977", "72", "578", "986", "96", "975", "108", "132", "116", "950", "124", "136", "152", "990", "156", "170", "970", "174", "976", "554", "188", "192", "931", "532", "203", "208", "262", "214", "818", "222", "232", "748", "230", "238", "242", "953", "270", "981", "936", "292", "320", "826", "324", "328", "332", "340", "344", "348", "352", "360", "364", "368", "376", "388", "392", "400", "398", "404", "408", "410", "414", "417", "418", "422", "426", "710", "430", "434", "756", "446", "807", "969", "454", "458", "462", "929", "480", "484", "979", "498", "496", "504", "943", "104", "516", "524", "558", "566", "512", "586", "590", "598", "600", "604", "608", "985", "634", "946", "643", "646", "654", "882", "930", "682", "941", "690", "694", "925", "702", "90", "706", "728", "144", "938", "968", "752", "947", "948", "760", "901", "972", "834", "764", "776", "780", "788", "949", "934", "800", "980", "784", "997", "858", "940", "927", "860", "548", "928", "926", "704", "886", "967", "932"]); const _io0 = input => (undefined === input.persistentAddresses || Array.isArray(input.persistentAddresses) && input.persistentAddresses.every(elem => "object" === typeof elem && null !== elem && _io1(elem))) && (undefined === input.from || "object" === typeof input.from && null !== input.from && _io6(input.from)) && (undefined === input.to || "object" === typeof input.to && null !== input.to && _io9(input.to)) && (undefined === input.pagination || "object" === typeof input.pagination && null !== input.pagination && false === Array.isArray(input.pagination) && _io10(input.pagination)); const _io1 = input => null !== input.location && undefined !== input.location && ("string" === typeof input.location && (RegExp(/^chain:keeta:[+-]?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/).test(input.location) || RegExp(/^chain:evm:[+-]?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/).test(input.location)) || "object" === typeof input.location && null !== input.location && _iu0(input.location)) && "string" === typeof input.persistentAddress; const _io2 = input => "chain" === input.type && ("object" === typeof input.chain && null !== input.chain && _iu1(input.chain)); const _io3 = input => "keeta" === input.type && "bigint" === typeof input.networkId; const _io4 = input => "evm" === input.type && "bigint" === typeof input.chainId; const _io5 = input => "bank-account" === input.type && (null !== input.workInProgress && undefined === input.workInProgress); const _io6 = input => null !== input.location && undefined !== input.location && ("string" === typeof input.location && (RegExp(/^chain:keeta:[+-]?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/).test(input.location) || RegExp(/^chain:evm:[+-]?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/).test(input.location)) || "object" === typeof input.location && null !== input.location && _iu0(input.location)) && (undefined === input.userAddress || "string" === typeof input.userAddress) && (null !== input.asset && (undefined === input.asset || "string" === typeof input.asset && (RegExp(/^keeta_am(.*)/).test(input.asset) || RegExp(/^keeta_an(.*)/).test(input.asset) || RegExp(/^keeta_ao(.*)/).test(input.asset) || RegExp(/^keeta_ap(.*)/).test(input.asset) || RegExp(/^tyblocks_am(.*)/).test(input.asset) || RegExp(/^tyblocks_an(.*)/).test(input.asset) || RegExp(/^tyblocks_ao(.*)/).test(input.asset) || RegExp(/^tyblocks_ap(.*)/).test(input.asset)) || "object" === typeof input.asset && null !== input.asset && _iu2(input.asset))); const _io7 = input => true && true === _iv2.has(input.code) && "string" === typeof input.name && "string" === typeof input.precision && true === _iv3.has(input.isoNumber); const _io8 = input => true; const _io9 = input => null !== input.location && undefined !== input.location && ("string" === typeof input.location && (RegExp(/^chain:keeta:[+-]?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/).test(input.location) || RegExp(/^chain:evm:[+-]?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/).test(input.location)) || "object" === typeof input.location && null !== input.location && _iu0(input.location)) && (undefined === input.userAddress || "string" === typeof input.userAddress) && (null !== input.asset && (undefined === input.asset || "string" === typeof input.asset && (RegExp(/^keeta_am(.*)/).test(input.asset) || RegExp(/^keeta_an(.*)/).test(input.asset) || RegExp(/^keeta_ao(.*)/).test(input.asset) || RegExp(/^keeta_ap(.*)/).test(input.asset) || RegExp(/^tyblocks_am(.*)/).test(input.asset) || RegExp(/^tyblocks_an(.*)/).test(input.asset) || RegExp(/^tyblocks_ao(.*)/).test(input.asset) || RegExp(/^tyblocks_ap(.*)/).test(input.asset)) || "object" === typeof input.asset && null !== input.asset && _iu2(input.asset))); const _io10 = input => (undefined === input.limit || "number" === typeof input.limit) && (undefined === input.offset || "number" === typeof input.offset); const _iu0 = input => (() => {
+    if ("chain" === input.type)
+        return _io2(input);
+    else if ("bank-account" === input.type)
+        return _io5(input);
+    else
+        return false;
+})(); const _iu1 = input => (() => {
+    if ("keeta" === input.type)
+        return _io3(input);
+    else if ("evm" === input.type)
+        return _io4(input);
+    else
+        return false;
+})(); const _iu2 = input => (() => {
+    if (undefined !== input.code)
+        return _io7(input);
+    else
+        return _io8(input);
+})(); const _ao0 = (input, _path, _exceptionable = true) => (undefined === input.persistentAddresses || (Array.isArray(input.persistentAddresses) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".persistentAddresses",
+    expected: "(Array<__type> | undefined)",
+    value: input.persistentAddresses
+}, _errorFactory)) && input.persistentAddresses.every((elem, _index4) => ("object" === typeof elem && null !== elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".persistentAddresses[" + _index4 + "]",
+    expected: "__type",
+    value: elem
+}, _errorFactory)) && _ao1(elem, _path + ".persistentAddresses[" + _index4 + "]", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".persistentAddresses[" + _index4 + "]",
+    expected: "__type",
+    value: elem
+}, _errorFactory)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".persistentAddresses",
+    expected: "(Array<__type> | undefined)",
+    value: input.persistentAddresses
+}, _errorFactory)) && (undefined === input.from || ("object" === typeof input.from && null !== input.from || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".from",
+    expected: "(__type.o5 | undefined)",
+    value: input.from
+}, _errorFactory)) && _ao6(input.from, _path + ".from", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".from",
+    expected: "(__type.o5 | undefined)",
+    value: input.from
+}, _errorFactory)) && (undefined === input.to || ("object" === typeof input.to && null !== input.to || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".to",
+    expected: "(__type.o6 | undefined)",
+    value: input.to
+}, _errorFactory)) && _ao9(input.to, _path + ".to", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".to",
+    expected: "(__type.o6 | undefined)",
+    value: input.to
+}, _errorFactory)) && (undefined === input.pagination || ("object" === typeof input.pagination && null !== input.pagination && false === Array.isArray(input.pagination) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".pagination",
+    expected: "(PaginationQuery | undefined)",
+    value: input.pagination
+}, _errorFactory)) && _ao10(input.pagination, _path + ".pagination", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".pagination",
+    expected: "(PaginationQuery | undefined)",
+    value: input.pagination
+}, _errorFactory)); const _ao1 = (input, _path, _exceptionable = true) => (null !== input.location || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".location",
+    expected: "(__type.o1 | __type.o4 | `chain:evm:${bigint}` | `chain:keeta:${bigint}`)",
+    value: input.location
+}, _errorFactory)) && (undefined !== input.location || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".location",
+    expected: "(__type.o1 | __type.o4 | `chain:evm:${bigint}` | `chain:keeta:${bigint}`)",
+    value: input.location
+}, _errorFactory)) && ("string" === typeof input.location && (RegExp(/^chain:keeta:[+-]?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/).test(input.location) || RegExp(/^chain:evm:[+-]?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/).test(input.location)) || ("object" === typeof input.location && null !== input.location || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".location",
+    expected: "(__type.o1 | __type.o4 | `chain:evm:${bigint}` | `chain:keeta:${bigint}`)",
+    value: input.location
+}, _errorFactory)) && _au0(input.location, _path + ".location", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".location",
+    expected: "(__type.o1 | __type.o4 | `chain:evm:${bigint}` | `chain:keeta:${bigint}`)",
+    value: input.location
+}, _errorFactory)) && ("string" === typeof input.persistentAddress || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".persistentAddress",
+    expected: "string",
+    value: input.persistentAddress
+}, _errorFactory)); const _ao2 = (input, _path, _exceptionable = true) => ("chain" === input.type || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".type",
+    expected: "\"chain\"",
+    value: input.type
+}, _errorFactory)) && (("object" === typeof input.chain && null !== input.chain || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".chain",
+    expected: "(__type.o2 | __type.o3)",
+    value: input.chain
+}, _errorFactory)) && _au1(input.chain, _path + ".chain", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".chain",
+    expected: "(__type.o2 | __type.o3)",
+    value: input.chain
+}, _errorFactory)); const _ao3 = (input, _path, _exceptionable = true) => ("keeta" === input.type || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".type",
+    expected: "\"keeta\"",
+    value: input.type
+}, _errorFactory)) && ("bigint" === typeof input.networkId || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".networkId",
+    expected: "bigint",
+    value: input.networkId
+}, _errorFactory)); const _ao4 = (input, _path, _exceptionable = true) => ("evm" === input.type || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".type",
+    expected: "\"evm\"",
+    value: input.type
+}, _errorFactory)) && ("bigint" === typeof input.chainId || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".chainId",
+    expected: "bigint",
+    value: input.chainId
+}, _errorFactory)); const _ao5 = (input, _path, _exceptionable = true) => ("bank-account" === input.type || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".type",
+    expected: "\"bank-account\"",
+    value: input.type
+}, _errorFactory)) && ((null !== input.workInProgress || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".workInProgress",
+    expected: "undefined",
+    value: input.workInProgress
+}, _errorFactory)) && (undefined === input.workInProgress || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".workInProgress",
+    expected: "undefined",
+    value: input.workInProgress
+}, _errorFactory))); const _ao6 = (input, _path, _exceptionable = true) => (null !== input.location || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".location",
+    expected: "(__type.o1 | __type.o4 | `chain:evm:${bigint}` | `chain:keeta:${bigint}`)",
+    value: input.location
+}, _errorFactory)) && (undefined !== input.location || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".location",
+    expected: "(__type.o1 | __type.o4 | `chain:evm:${bigint}` | `chain:keeta:${bigint}`)",
+    value: input.location
+}, _errorFactory)) && ("string" === typeof input.location && (RegExp(/^chain:keeta:[+-]?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/).test(input.location) || RegExp(/^chain:evm:[+-]?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/).test(input.location)) || ("object" === typeof input.location && null !== input.location || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".location",
+    expected: "(__type.o1 | __type.o4 | `chain:evm:${bigint}` | `chain:keeta:${bigint}`)",
+    value: input.location
+}, _errorFactory)) && _au0(input.location, _path + ".location", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".location",
+    expected: "(__type.o1 | __type.o4 | `chain:evm:${bigint}` | `chain:keeta:${bigint}`)",
+    value: input.location
+}, _errorFactory)) && (undefined === input.userAddress || "string" === typeof input.userAddress || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".userAddress",
+    expected: "(string | undefined)",
+    value: input.userAddress
+}, _errorFactory)) && ((null !== input.asset || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".asset",
+    expected: "(Currency | TokenAddress | `keeta_am${string}` | `keeta_an${string}` | `keeta_ao${string}` | `keeta_ap${string}` | `tyblocks_am${string}` | `tyblocks_an${string}` | `tyblocks_ao${string}` | `tyblocks_ap${string}` | undefined)",
+    value: input.asset
+}, _errorFactory)) && (undefined === input.asset || "string" === typeof input.asset && (RegExp(/^keeta_am(.*)/).test(input.asset) || RegExp(/^keeta_an(.*)/).test(input.asset) || RegExp(/^keeta_ao(.*)/).test(input.asset) || RegExp(/^keeta_ap(.*)/).test(input.asset) || RegExp(/^tyblocks_am(.*)/).test(input.asset) || RegExp(/^tyblocks_an(.*)/).test(input.asset) || RegExp(/^tyblocks_ao(.*)/).test(input.asset) || RegExp(/^tyblocks_ap(.*)/).test(input.asset)) || ("object" === typeof input.asset && null !== input.asset || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".asset",
+    expected: "(Currency | TokenAddress | `keeta_am${string}` | `keeta_an${string}` | `keeta_ao${string}` | `keeta_ap${string}` | `tyblocks_am${string}` | `tyblocks_an${string}` | `tyblocks_ao${string}` | `tyblocks_ap${string}` | undefined)",
+    value: input.asset
+}, _errorFactory)) && _au2(input.asset, _path + ".asset", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".asset",
+    expected: "(Currency | TokenAddress | `keeta_am${string}` | `keeta_an${string}` | `keeta_ao${string}` | `keeta_ap${string}` | `tyblocks_am${string}` | `tyblocks_an${string}` | `tyblocks_ao${string}` | `tyblocks_ap${string}` | undefined)",
+    value: input.asset
+}, _errorFactory))); const _ao7 = (input, _path, _exceptionable = true) => true && (true === _av5.has(input.code) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".code",
+    expected: "(\"AED\" | \"AFN\" | \"ALL\" | \"AMD\" | \"ANG\" | \"AOA\" | \"ARS\" | \"AUD\" | \"AWG\" | \"AZN\" | \"BAM\" | \"BBD\" | \"BDT\" | \"BGN\" | \"BHD\" | \"BIF\" | \"BMD\" | \"BND\" | \"BOB\" | \"BOV\" | \"BRL\" | \"BSD\" | \"BTN\" | \"BWP\" | \"BYN\" | \"BZD\" | \"CAD\" | \"CDF\" | \"CHE\" | \"CHF\" | \"CHW\" | \"CLF\" | \"CLP\" | \"CNY\" | \"COP\" | \"COU\" | \"CRC\" | \"CUC\" | \"CUP\" | \"CVE\" | \"CZK\" | \"DJF\" | \"DKK\" | \"DOP\" | \"DZD\" | \"EGP\" | \"ERN\" | \"ETB\" | \"EUR\" | \"FJD\" | \"FKP\" | \"GBP\" | \"GEL\" | \"GHS\" | \"GIP\" | \"GMD\" | \"GNF\" | \"GTQ\" | \"GYD\" | \"HKD\" | \"HNL\" | \"HTG\" | \"HUF\" | \"IDR\" | \"ILS\" | \"INR\" | \"IQD\" | \"IRR\" | \"ISK\" | \"JMD\" | \"JOD\" | \"JPY\" | \"KES\" | \"KGS\" | \"KHR\" | \"KMF\" | \"KPW\" | \"KRW\" | \"KWD\" | \"KYD\" | \"KZT\" | \"LAK\" | \"LBP\" | \"LKR\" | \"LRD\" | \"LSL\" | \"LYD\" | \"MAD\" | \"MDL\" | \"MGA\" | \"MKD\" | \"MMK\" | \"MNT\" | \"MOP\" | \"MRU\" | \"MUR\" | \"MVR\" | \"MWK\" | \"MXN\" | \"MXV\" | \"MYR\" | \"MZN\" | \"NAD\" | \"NGN\" | \"NIO\" | \"NOK\" | \"NPR\" | \"NZD\" | \"OMR\" | \"PAB\" | \"PEN\" | \"PGK\" | \"PHP\" | \"PKR\" | \"PLN\" | \"PYG\" | \"QAR\" | \"RON\" | \"RSD\" | \"RUB\" | \"RWF\" | \"SAR\" | \"SBD\" | \"SCR\" | \"SDG\" | \"SEK\" | \"SGD\" | \"SHP\" | \"SLE\" | \"SLL\" | \"SOS\" | \"SRD\" | \"SSP\" | \"STN\" | \"SVC\" | \"SYP\" | \"SZL\" | \"THB\" | \"TJS\" | \"TMT\" | \"TND\" | \"TOP\" | \"TRY\" | \"TTD\" | \"TWD\" | \"TZS\" | \"UAH\" | \"UGX\" | \"USD\" | \"USN\" | \"UYI\" | \"UYU\" | \"UYW\" | \"UZS\" | \"VED\" | \"VES\" | \"VND\" | \"VUV\" | \"WST\" | \"XAF\" | \"XCD\" | \"XOF\" | \"XPF\" | \"YER\" | \"ZAR\" | \"ZMW\" | \"ZWL\")",
+    value: input.code
+}, _errorFactory)) && ("string" === typeof input.name || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".name",
+    expected: "string",
+    value: input.name
+}, _errorFactory)) && ("string" === typeof input.precision || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".precision",
+    expected: "string",
+    value: input.precision
+}, _errorFactory)) && (true === _av6.has(input.isoNumber) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".isoNumber",
+    expected: "(\"104\" | \"108\" | \"116\" | \"12\" | \"124\" | \"132\" | \"136\" | \"144\" | \"152\" | \"156\" | \"170\" | \"174\" | \"188\" | \"192\" | \"203\" | \"208\" | \"214\" | \"222\" | \"230\" | \"232\" | \"238\" | \"242\" | \"262\" | \"270\" | \"292\" | \"32\" | \"320\" | \"324\" | \"328\" | \"332\" | \"340\" | \"344\" | \"348\" | \"352\" | \"356\" | \"36\" | \"360\" | \"364\" | \"368\" | \"376\" | \"388\" | \"392\" | \"398\" | \"400\" | \"404\" | \"408\" | \"410\" | \"414\" | \"417\" | \"418\" | \"422\" | \"426\" | \"430\" | \"434\" | \"44\" | \"446\" | \"454\" | \"458\" | \"462\" | \"48\" | \"480\" | \"484\" | \"496\" | \"498\" | \"50\" | \"504\" | \"51\" | \"512\" | \"516\" | \"52\" | \"524\" | \"532\" | \"533\" | \"548\" | \"554\" | \"558\" | \"566\" | \"578\" | \"586\" | \"590\" | \"598\" | \"60\" | \"600\" | \"604\" | \"608\" | \"634\" | \"64\" | \"643\" | \"646\" | \"654\" | \"68\" | \"682\" | \"690\" | \"694\" | \"702\" | \"704\" | \"706\" | \"710\" | \"72\" | \"728\" | \"748\" | \"752\" | \"756\" | \"760\" | \"764\" | \"776\" | \"780\" | \"784\" | \"788\" | \"8\" | \"800\" | \"807\" | \"818\" | \"826\" | \"834\" | \"84\" | \"840\" | \"858\" | \"860\" | \"882\" | \"886\" | \"90\" | \"901\" | \"925\" | \"926\" | \"927\" | \"928\" | \"929\" | \"930\" | \"931\" | \"932\" | \"933\" | \"934\" | \"936\" | \"938\" | \"940\" | \"941\" | \"943\" | \"944\" | \"946\" | \"947\" | \"948\" | \"949\" | \"950\" | \"951\" | \"952\" | \"953\" | \"96\" | \"967\" | \"968\" | \"969\" | \"970\" | \"971\" | \"972\" | \"973\" | \"975\" | \"976\" | \"977\" | \"978\" | \"979\" | \"980\" | \"981\" | \"984\" | \"985\" | \"986\" | \"990\" | \"997\")",
+    value: input.isoNumber
+}, _errorFactory)); const _ao8 = (input, _path, _exceptionable = true) => true; const _ao9 = (input, _path, _exceptionable = true) => (null !== input.location || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".location",
+    expected: "(__type.o1 | __type.o4 | `chain:evm:${bigint}` | `chain:keeta:${bigint}`)",
+    value: input.location
+}, _errorFactory)) && (undefined !== input.location || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".location",
+    expected: "(__type.o1 | __type.o4 | `chain:evm:${bigint}` | `chain:keeta:${bigint}`)",
+    value: input.location
+}, _errorFactory)) && ("string" === typeof input.location && (RegExp(/^chain:keeta:[+-]?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/).test(input.location) || RegExp(/^chain:evm:[+-]?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/).test(input.location)) || ("object" === typeof input.location && null !== input.location || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".location",
+    expected: "(__type.o1 | __type.o4 | `chain:evm:${bigint}` | `chain:keeta:${bigint}`)",
+    value: input.location
+}, _errorFactory)) && _au0(input.location, _path + ".location", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".location",
+    expected: "(__type.o1 | __type.o4 | `chain:evm:${bigint}` | `chain:keeta:${bigint}`)",
+    value: input.location
+}, _errorFactory)) && (undefined === input.userAddress || "string" === typeof input.userAddress || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".userAddress",
+    expected: "(string | undefined)",
+    value: input.userAddress
+}, _errorFactory)) && ((null !== input.asset || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".asset",
+    expected: "(Currency | TokenAddress | `keeta_am${string}` | `keeta_an${string}` | `keeta_ao${string}` | `keeta_ap${string}` | `tyblocks_am${string}` | `tyblocks_an${string}` | `tyblocks_ao${string}` | `tyblocks_ap${string}` | undefined)",
+    value: input.asset
+}, _errorFactory)) && (undefined === input.asset || "string" === typeof input.asset && (RegExp(/^keeta_am(.*)/).test(input.asset) || RegExp(/^keeta_an(.*)/).test(input.asset) || RegExp(/^keeta_ao(.*)/).test(input.asset) || RegExp(/^keeta_ap(.*)/).test(input.asset) || RegExp(/^tyblocks_am(.*)/).test(input.asset) || RegExp(/^tyblocks_an(.*)/).test(input.asset) || RegExp(/^tyblocks_ao(.*)/).test(input.asset) || RegExp(/^tyblocks_ap(.*)/).test(input.asset)) || ("object" === typeof input.asset && null !== input.asset || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".asset",
+    expected: "(Currency | TokenAddress | `keeta_am${string}` | `keeta_an${string}` | `keeta_ao${string}` | `keeta_ap${string}` | `tyblocks_am${string}` | `tyblocks_an${string}` | `tyblocks_ao${string}` | `tyblocks_ap${string}` | undefined)",
+    value: input.asset
+}, _errorFactory)) && _au2(input.asset, _path + ".asset", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".asset",
+    expected: "(Currency | TokenAddress | `keeta_am${string}` | `keeta_an${string}` | `keeta_ao${string}` | `keeta_ap${string}` | `tyblocks_am${string}` | `tyblocks_an${string}` | `tyblocks_ao${string}` | `tyblocks_ap${string}` | undefined)",
+    value: input.asset
+}, _errorFactory))); const _ao10 = (input, _path, _exceptionable = true) => (undefined === input.limit || "number" === typeof input.limit || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".limit",
+    expected: "(number | undefined)",
+    value: input.limit
+}, _errorFactory)) && (undefined === input.offset || "number" === typeof input.offset || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".offset",
+    expected: "(number | undefined)",
+    value: input.offset
+}, _errorFactory)); const _au0 = (input, _path, _exceptionable = true) => (() => {
+    if ("chain" === input.type)
+        return _ao2(input, _path, true && _exceptionable);
+    else if ("bank-account" === input.type)
+        return _ao5(input, _path, true && _exceptionable);
+    else
+        return __typia_transform__assertGuard._assertGuard(_exceptionable, {
+            method: "createAssert",
+            path: _path,
+            expected: "(__type.o1 | __type.o4)",
+            value: input
+        }, _errorFactory);
+})(); const _au1 = (input, _path, _exceptionable = true) => (() => {
+    if ("keeta" === input.type)
+        return _ao3(input, _path, true && _exceptionable);
+    else if ("evm" === input.type)
+        return _ao4(input, _path, true && _exceptionable);
+    else
+        return __typia_transform__assertGuard._assertGuard(_exceptionable, {
+            method: "createAssert",
+            path: _path,
+            expected: "(__type.o2 | __type.o3)",
+            value: input
+        }, _errorFactory);
+})(); const _au2 = (input, _path, _exceptionable = true) => (() => {
+    if (undefined !== input.code)
+        return _ao7(input, _path, true && _exceptionable);
+    else
+        return _ao8(input, _path, true && _exceptionable);
+})(); const __is = input => "object" === typeof input && null !== input && false === Array.isArray(input) && _io0(input); let _errorFactory; return (input, errorFactory) => {
+    if (false === __is(input)) {
+        _errorFactory = errorFactory;
+        ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input && false === Array.isArray(input) || __typia_transform__assertGuard._assertGuard(true, {
+            method: "createAssert",
+            path: _path + "",
+            expected: "KeetaAssetMovementAnchorlistTransactionsRequest",
+            value: input
+        }, _errorFactory)) && _ao0(input, _path + "", true) || __typia_transform__assertGuard._assertGuard(true, {
+            method: "createAssert",
+            path: _path + "",
+            expected: "KeetaAssetMovementAnchorlistTransactionsRequest",
+            value: input
+        }, _errorFactory))(input, "$input", true);
+    }
+    return input;
+}; })();
+export const assertKeetaAssetMovementAnchorlistPersistentForwardingTransactionsResponse = (() => { const _iv2 = new Set(["ALL", "AFN", "EUR", "DZD", "USD", "AOA", "XCD", "ARS", "AMD", "AWG", "AUD", "AZN", "BSD", "BHD", "BDT", "BBD", "BYN", "BZD", "XOF", "BMD", "INR", "BTN", "BOB", "BOV", "BAM", "BWP", "NOK", "BRL", "BND", "BGN", "BIF", "CVE", "KHR", "XAF", "CAD", "KYD", "CLP", "CLF", "CNY", "COP", "COU", "KMF", "CDF", "NZD", "CRC", "CUP", "CUC", "ANG", "CZK", "DKK", "DJF", "DOP", "EGP", "SVC", "ERN", "SZL", "ETB", "FKP", "FJD", "XPF", "GMD", "GEL", "GHS", "GIP", "GTQ", "GBP", "GNF", "GYD", "HTG", "HNL", "HKD", "HUF", "ISK", "IDR", "IRR", "IQD", "ILS", "JMD", "JPY", "JOD", "KZT", "KES", "KPW", "KRW", "KWD", "KGS", "LAK", "LBP", "LSL", "ZAR", "LRD", "LYD", "CHF", "MOP", "MKD", "MGA", "MWK", "MYR", "MVR", "MRU", "MUR", "MXN", "MXV", "MDL", "MNT", "MAD", "MZN", "MMK", "NAD", "NPR", "NIO", "NGN", "OMR", "PKR", "PAB", "PGK", "PYG", "PEN", "PHP", "PLN", "QAR", "RON", "RUB", "RWF", "SHP", "WST", "STN", "SAR", "RSD", "SCR", "SLL", "SLE", "SGD", "SBD", "SOS", "SSP", "LKR", "SDG", "SRD", "SEK", "CHE", "CHW", "SYP", "TWD", "TJS", "TZS", "THB", "TOP", "TTD", "TND", "TRY", "TMT", "UGX", "UAH", "AED", "USN", "UYU", "UYI", "UYW", "UZS", "VUV", "VES", "VED", "VND", "YER", "ZMW", "ZWL"]); const _iv3 = new Set(["971", "978", "8", "12", "840", "973", "951", "32", "51", "533", "36", "944", "44", "48", "50", "52", "933", "84", "952", "60", "356", "64", "68", "984", "977", "72", "578", "986", "96", "975", "108", "132", "116", "950", "124", "136", "152", "990", "156", "170", "970", "174", "976", "554", "188", "192", "931", "532", "203", "208", "262", "214", "818", "222", "232", "748", "230", "238", "242", "953", "270", "981", "936", "292", "320", "826", "324", "328", "332", "340", "344", "348", "352", "360", "364", "368", "376", "388", "392", "400", "398", "404", "408", "410", "414", "417", "418", "422", "426", "710", "430", "434", "756", "446", "807", "969", "454", "458", "462", "929", "480", "484", "979", "498", "496", "504", "943", "104", "516", "524", "558", "566", "512", "586", "590", "598", "600", "604", "608", "985", "634", "946", "643", "646", "654", "882", "930", "682", "941", "690", "694", "925", "702", "90", "706", "728", "144", "938", "968", "752", "947", "948", "760", "901", "972", "834", "764", "776", "780", "788", "949", "934", "800", "980", "784", "997", "858", "940", "927", "860", "548", "928", "926", "704", "886", "967", "932"]); const _av5 = new Set(["ALL", "AFN", "EUR", "DZD", "USD", "AOA", "XCD", "ARS", "AMD", "AWG", "AUD", "AZN", "BSD", "BHD", "BDT", "BBD", "BYN", "BZD", "XOF", "BMD", "INR", "BTN", "BOB", "BOV", "BAM", "BWP", "NOK", "BRL", "BND", "BGN", "BIF", "CVE", "KHR", "XAF", "CAD", "KYD", "CLP", "CLF", "CNY", "COP", "COU", "KMF", "CDF", "NZD", "CRC", "CUP", "CUC", "ANG", "CZK", "DKK", "DJF", "DOP", "EGP", "SVC", "ERN", "SZL", "ETB", "FKP", "FJD", "XPF", "GMD", "GEL", "GHS", "GIP", "GTQ", "GBP", "GNF", "GYD", "HTG", "HNL", "HKD", "HUF", "ISK", "IDR", "IRR", "IQD", "ILS", "JMD", "JPY", "JOD", "KZT", "KES", "KPW", "KRW", "KWD", "KGS", "LAK", "LBP", "LSL", "ZAR", "LRD", "LYD", "CHF", "MOP", "MKD", "MGA", "MWK", "MYR", "MVR", "MRU", "MUR", "MXN", "MXV", "MDL", "MNT", "MAD", "MZN", "MMK", "NAD", "NPR", "NIO", "NGN", "OMR", "PKR", "PAB", "PGK", "PYG", "PEN", "PHP", "PLN", "QAR", "RON", "RUB", "RWF", "SHP", "WST", "STN", "SAR", "RSD", "SCR", "SLL", "SLE", "SGD", "SBD", "SOS", "SSP", "LKR", "SDG", "SRD", "SEK", "CHE", "CHW", "SYP", "TWD", "TJS", "TZS", "THB", "TOP", "TTD", "TND", "TRY", "TMT", "UGX", "UAH", "AED", "USN", "UYU", "UYI", "UYW", "UZS", "VUV", "VES", "VED", "VND", "YER", "ZMW", "ZWL"]); const _av6 = new Set(["971", "978", "8", "12", "840", "973", "951", "32", "51", "533", "36", "944", "44", "48", "50", "52", "933", "84", "952", "60", "356", "64", "68", "984", "977", "72", "578", "986", "96", "975", "108", "132", "116", "950", "124", "136", "152", "990", "156", "170", "970", "174", "976", "554", "188", "192", "931", "532", "203", "208", "262", "214", "818", "222", "232", "748", "230", "238", "242", "953", "270", "981", "936", "292", "320", "826", "324", "328", "332", "340", "344", "348", "352", "360", "364", "368", "376", "388", "392", "400", "398", "404", "408", "410", "414", "417", "418", "422", "426", "710", "430", "434", "756", "446", "807", "969", "454", "458", "462", "929", "480", "484", "979", "498", "496", "504", "943", "104", "516", "524", "558", "566", "512", "586", "590", "598", "600", "604", "608", "985", "634", "946", "643", "646", "654", "882", "930", "682", "941", "690", "694", "925", "702", "90", "706", "728", "144", "938", "968", "752", "947", "948", "760", "901", "972", "834", "764", "776", "780", "788", "949", "934", "800", "980", "784", "997", "858", "940", "927", "860", "548", "928", "926", "704", "886", "967", "932"]); const _io0 = (input, _exceptionable = true) => true === input.ok && (Array.isArray(input.transactions) && input.transactions.every((elem, _index1) => "object" === typeof elem && null !== elem && _io1(elem, true && _exceptionable))) && "string" === typeof input.total && (3 === Object.keys(input).length || Object.keys(input).every(key => {
+    if (["ok", "transactions", "total"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return false;
+})); const _io1 = (input, _exceptionable = true) => "string" === typeof input.id && "string" === typeof input.status && (null !== input.asset && undefined !== input.asset && ("string" === typeof input.asset && (RegExp(/^keeta_am(.*)/).test(input.asset) || RegExp(/^keeta_an(.*)/).test(input.asset) || RegExp(/^keeta_ao(.*)/).test(input.asset) || RegExp(/^keeta_ap(.*)/).test(input.asset) || RegExp(/^tyblocks_am(.*)/).test(input.asset) || RegExp(/^tyblocks_an(.*)/).test(input.asset) || RegExp(/^tyblocks_ao(.*)/).test(input.asset) || RegExp(/^tyblocks_ap(.*)/).test(input.asset)) || "object" === typeof input.asset && null !== input.asset && _iu0(input.asset, true && _exceptionable))) && ("object" === typeof input.from && null !== input.from && _io4(input.from, true && _exceptionable)) && ("object" === typeof input.to && null !== input.to && _io7(input.to, true && _exceptionable)) && (null === input.fee || "object" === typeof input.fee && null !== input.fee && _io9(input.fee, true && _exceptionable)) && "string" === typeof input.createdAt && "string" === typeof input.updatedAt && (8 === Object.keys(input).length || Object.keys(input).every(key => {
+    if (["id", "status", "asset", "from", "to", "fee", "createdAt", "updatedAt"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return false;
+})); const _io2 = (input, _exceptionable = true) => true && true === _iv2.has(input.code) && "string" === typeof input.name && "string" === typeof input.precision && true === _iv3.has(input.isoNumber) && (5 === Object.keys(input).length || Object.keys(input).every(key => {
+    if (["#private", "code", "name", "precision", "isoNumber"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return false;
+})); const _io3 = (input, _exceptionable = true) => true && (1 === Object.keys(input).length || Object.keys(input).every(key => {
+    if (["#private"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return false;
+})); const _io4 = (input, _exceptionable = true) => "string" === typeof input.location && (RegExp(/^chain:keeta:[+-]?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/).test(input.location) || RegExp(/^chain:evm:[+-]?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/).test(input.location)) && "string" === typeof input.value && ("object" === typeof input.transactions && null !== input.transactions && _io5(input.transactions, true && _exceptionable)) && (3 === Object.keys(input).length || Object.keys(input).every(key => {
+    if (["location", "value", "transactions"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return false;
+})); const _io5 = (input, _exceptionable = true) => (null === input.persistentForwarding || "object" === typeof input.persistentForwarding && null !== input.persistentForwarding && _io6(input.persistentForwarding, true && _exceptionable)) && (null === input.deposit || "object" === typeof input.deposit && null !== input.deposit && _io6(input.deposit, true && _exceptionable)) && (null === input.finalization || "object" === typeof input.finalization && null !== input.finalization && _io6(input.finalization, true && _exceptionable)) && (3 === Object.keys(input).length || Object.keys(input).every(key => {
+    if (["persistentForwarding", "deposit", "finalization"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return false;
+})); const _io6 = (input, _exceptionable = true) => "string" === typeof input.id && "string" === typeof input.nonce && (2 === Object.keys(input).length || Object.keys(input).every(key => {
+    if (["id", "nonce"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return false;
+})); const _io7 = (input, _exceptionable = true) => "string" === typeof input.location && (RegExp(/^chain:keeta:[+-]?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/).test(input.location) || RegExp(/^chain:evm:[+-]?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/).test(input.location)) && "string" === typeof input.value && ("object" === typeof input.transactions && null !== input.transactions && _io8(input.transactions, true && _exceptionable)) && (3 === Object.keys(input).length || Object.keys(input).every(key => {
+    if (["location", "value", "transactions"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return false;
+})); const _io8 = (input, _exceptionable = true) => (null === input.withdraw || "object" === typeof input.withdraw && null !== input.withdraw && _io6(input.withdraw, true && _exceptionable)) && (1 === Object.keys(input).length || Object.keys(input).every(key => {
+    if (["withdraw"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return false;
+})); const _io9 = (input, _exceptionable = true) => null !== input.asset && undefined !== input.asset && ("string" === typeof input.asset && (RegExp(/^keeta_am(.*)/).test(input.asset) || RegExp(/^keeta_an(.*)/).test(input.asset) || RegExp(/^keeta_ao(.*)/).test(input.asset) || RegExp(/^keeta_ap(.*)/).test(input.asset) || RegExp(/^tyblocks_am(.*)/).test(input.asset) || RegExp(/^tyblocks_an(.*)/).test(input.asset) || RegExp(/^tyblocks_ao(.*)/).test(input.asset) || RegExp(/^tyblocks_ap(.*)/).test(input.asset)) || "object" === typeof input.asset && null !== input.asset && _iu0(input.asset, true && _exceptionable)) && "string" === typeof input.value && (2 === Object.keys(input).length || Object.keys(input).every(key => {
+    if (["asset", "value"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return false;
+})); const _io10 = (input, _exceptionable = true) => false === input.ok && "string" === typeof input.error && (2 === Object.keys(input).length || Object.keys(input).every(key => {
+    if (["ok", "error"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return false;
+})); const _iu0 = (input, _exceptionable = true) => (() => {
+    if (undefined !== input.code)
+        return _io2(input, true && _exceptionable);
+    else
+        return _io3(input, true && _exceptionable);
+})(); const _iu1 = (input, _exceptionable = true) => (() => {
+    if (true === input.ok)
+        return _io0(input, true && _exceptionable);
+    else if (false === input.ok)
+        return _io10(input, true && _exceptionable);
+    else
+        return false;
+})(); const _ao0 = (input, _path, _exceptionable = true) => (true === input.ok || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".ok",
+    expected: "true",
+    value: input.ok
+}, _errorFactory)) && ((Array.isArray(input.transactions) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".transactions",
+    expected: "Array<KeetaAssetMovementTransaction>",
+    value: input.transactions
+}, _errorFactory)) && input.transactions.every((elem, _index4) => ("object" === typeof elem && null !== elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".transactions[" + _index4 + "]",
+    expected: "KeetaAssetMovementTransaction",
+    value: elem
+}, _errorFactory)) && _ao1(elem, _path + ".transactions[" + _index4 + "]", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".transactions[" + _index4 + "]",
+    expected: "KeetaAssetMovementTransaction",
+    value: elem
+}, _errorFactory)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".transactions",
+    expected: "Array<KeetaAssetMovementTransaction>",
+    value: input.transactions
+}, _errorFactory)) && ("string" === typeof input.total || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".total",
+    expected: "string",
+    value: input.total
+}, _errorFactory)) && (3 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every(key => {
+    if (["ok", "transactions", "total"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return __typia_transform__assertGuard._assertGuard(_exceptionable, {
+        method: "createAssertEquals",
+        path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+        expected: "undefined",
+        value: value
+    }, _errorFactory);
+}))); const _ao1 = (input, _path, _exceptionable = true) => ("string" === typeof input.id || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".id",
+    expected: "string",
+    value: input.id
+}, _errorFactory)) && ("string" === typeof input.status || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".status",
+    expected: "string",
+    value: input.status
+}, _errorFactory)) && ((null !== input.asset || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".asset",
+    expected: "(Currency | TokenAddress | `keeta_am${string}` | `keeta_an${string}` | `keeta_ao${string}` | `keeta_ap${string}` | `tyblocks_am${string}` | `tyblocks_an${string}` | `tyblocks_ao${string}` | `tyblocks_ap${string}`)",
+    value: input.asset
+}, _errorFactory)) && (undefined !== input.asset || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".asset",
+    expected: "(Currency | TokenAddress | `keeta_am${string}` | `keeta_an${string}` | `keeta_ao${string}` | `keeta_ap${string}` | `tyblocks_am${string}` | `tyblocks_an${string}` | `tyblocks_ao${string}` | `tyblocks_ap${string}`)",
+    value: input.asset
+}, _errorFactory)) && ("string" === typeof input.asset && (RegExp(/^keeta_am(.*)/).test(input.asset) || RegExp(/^keeta_an(.*)/).test(input.asset) || RegExp(/^keeta_ao(.*)/).test(input.asset) || RegExp(/^keeta_ap(.*)/).test(input.asset) || RegExp(/^tyblocks_am(.*)/).test(input.asset) || RegExp(/^tyblocks_an(.*)/).test(input.asset) || RegExp(/^tyblocks_ao(.*)/).test(input.asset) || RegExp(/^tyblocks_ap(.*)/).test(input.asset)) || ("object" === typeof input.asset && null !== input.asset || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".asset",
+    expected: "(Currency | TokenAddress | `keeta_am${string}` | `keeta_an${string}` | `keeta_ao${string}` | `keeta_ap${string}` | `tyblocks_am${string}` | `tyblocks_an${string}` | `tyblocks_ao${string}` | `tyblocks_ap${string}`)",
+    value: input.asset
+}, _errorFactory)) && _au0(input.asset, _path + ".asset", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".asset",
+    expected: "(Currency | TokenAddress | `keeta_am${string}` | `keeta_an${string}` | `keeta_ao${string}` | `keeta_ap${string}` | `tyblocks_am${string}` | `tyblocks_an${string}` | `tyblocks_ao${string}` | `tyblocks_ap${string}`)",
+    value: input.asset
+}, _errorFactory))) && (("object" === typeof input.from && null !== input.from || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".from",
+    expected: "__type",
+    value: input.from
+}, _errorFactory)) && _ao4(input.from, _path + ".from", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".from",
+    expected: "__type",
+    value: input.from
+}, _errorFactory)) && (("object" === typeof input.to && null !== input.to || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".to",
+    expected: "__type.o1",
+    value: input.to
+}, _errorFactory)) && _ao7(input.to, _path + ".to", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".to",
+    expected: "__type.o1",
+    value: input.to
+}, _errorFactory)) && (null === input.fee || ("object" === typeof input.fee && null !== input.fee || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".fee",
+    expected: "(__type.o2 | null)",
+    value: input.fee
+}, _errorFactory)) && _ao9(input.fee, _path + ".fee", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".fee",
+    expected: "(__type.o2 | null)",
+    value: input.fee
+}, _errorFactory)) && ("string" === typeof input.createdAt || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".createdAt",
+    expected: "string",
+    value: input.createdAt
+}, _errorFactory)) && ("string" === typeof input.updatedAt || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".updatedAt",
+    expected: "string",
+    value: input.updatedAt
+}, _errorFactory)) && (8 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every(key => {
+    if (["id", "status", "asset", "from", "to", "fee", "createdAt", "updatedAt"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return __typia_transform__assertGuard._assertGuard(_exceptionable, {
+        method: "createAssertEquals",
+        path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+        expected: "undefined",
+        value: value
+    }, _errorFactory);
+}))); const _ao2 = (input, _path, _exceptionable = true) => true && (true === _av5.has(input.code) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".code",
+    expected: "(\"AED\" | \"AFN\" | \"ALL\" | \"AMD\" | \"ANG\" | \"AOA\" | \"ARS\" | \"AUD\" | \"AWG\" | \"AZN\" | \"BAM\" | \"BBD\" | \"BDT\" | \"BGN\" | \"BHD\" | \"BIF\" | \"BMD\" | \"BND\" | \"BOB\" | \"BOV\" | \"BRL\" | \"BSD\" | \"BTN\" | \"BWP\" | \"BYN\" | \"BZD\" | \"CAD\" | \"CDF\" | \"CHE\" | \"CHF\" | \"CHW\" | \"CLF\" | \"CLP\" | \"CNY\" | \"COP\" | \"COU\" | \"CRC\" | \"CUC\" | \"CUP\" | \"CVE\" | \"CZK\" | \"DJF\" | \"DKK\" | \"DOP\" | \"DZD\" | \"EGP\" | \"ERN\" | \"ETB\" | \"EUR\" | \"FJD\" | \"FKP\" | \"GBP\" | \"GEL\" | \"GHS\" | \"GIP\" | \"GMD\" | \"GNF\" | \"GTQ\" | \"GYD\" | \"HKD\" | \"HNL\" | \"HTG\" | \"HUF\" | \"IDR\" | \"ILS\" | \"INR\" | \"IQD\" | \"IRR\" | \"ISK\" | \"JMD\" | \"JOD\" | \"JPY\" | \"KES\" | \"KGS\" | \"KHR\" | \"KMF\" | \"KPW\" | \"KRW\" | \"KWD\" | \"KYD\" | \"KZT\" | \"LAK\" | \"LBP\" | \"LKR\" | \"LRD\" | \"LSL\" | \"LYD\" | \"MAD\" | \"MDL\" | \"MGA\" | \"MKD\" | \"MMK\" | \"MNT\" | \"MOP\" | \"MRU\" | \"MUR\" | \"MVR\" | \"MWK\" | \"MXN\" | \"MXV\" | \"MYR\" | \"MZN\" | \"NAD\" | \"NGN\" | \"NIO\" | \"NOK\" | \"NPR\" | \"NZD\" | \"OMR\" | \"PAB\" | \"PEN\" | \"PGK\" | \"PHP\" | \"PKR\" | \"PLN\" | \"PYG\" | \"QAR\" | \"RON\" | \"RSD\" | \"RUB\" | \"RWF\" | \"SAR\" | \"SBD\" | \"SCR\" | \"SDG\" | \"SEK\" | \"SGD\" | \"SHP\" | \"SLE\" | \"SLL\" | \"SOS\" | \"SRD\" | \"SSP\" | \"STN\" | \"SVC\" | \"SYP\" | \"SZL\" | \"THB\" | \"TJS\" | \"TMT\" | \"TND\" | \"TOP\" | \"TRY\" | \"TTD\" | \"TWD\" | \"TZS\" | \"UAH\" | \"UGX\" | \"USD\" | \"USN\" | \"UYI\" | \"UYU\" | \"UYW\" | \"UZS\" | \"VED\" | \"VES\" | \"VND\" | \"VUV\" | \"WST\" | \"XAF\" | \"XCD\" | \"XOF\" | \"XPF\" | \"YER\" | \"ZAR\" | \"ZMW\" | \"ZWL\")",
+    value: input.code
+}, _errorFactory)) && ("string" === typeof input.name || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".name",
+    expected: "string",
+    value: input.name
+}, _errorFactory)) && ("string" === typeof input.precision || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".precision",
+    expected: "string",
+    value: input.precision
+}, _errorFactory)) && (true === _av6.has(input.isoNumber) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".isoNumber",
+    expected: "(\"104\" | \"108\" | \"116\" | \"12\" | \"124\" | \"132\" | \"136\" | \"144\" | \"152\" | \"156\" | \"170\" | \"174\" | \"188\" | \"192\" | \"203\" | \"208\" | \"214\" | \"222\" | \"230\" | \"232\" | \"238\" | \"242\" | \"262\" | \"270\" | \"292\" | \"32\" | \"320\" | \"324\" | \"328\" | \"332\" | \"340\" | \"344\" | \"348\" | \"352\" | \"356\" | \"36\" | \"360\" | \"364\" | \"368\" | \"376\" | \"388\" | \"392\" | \"398\" | \"400\" | \"404\" | \"408\" | \"410\" | \"414\" | \"417\" | \"418\" | \"422\" | \"426\" | \"430\" | \"434\" | \"44\" | \"446\" | \"454\" | \"458\" | \"462\" | \"48\" | \"480\" | \"484\" | \"496\" | \"498\" | \"50\" | \"504\" | \"51\" | \"512\" | \"516\" | \"52\" | \"524\" | \"532\" | \"533\" | \"548\" | \"554\" | \"558\" | \"566\" | \"578\" | \"586\" | \"590\" | \"598\" | \"60\" | \"600\" | \"604\" | \"608\" | \"634\" | \"64\" | \"643\" | \"646\" | \"654\" | \"68\" | \"682\" | \"690\" | \"694\" | \"702\" | \"704\" | \"706\" | \"710\" | \"72\" | \"728\" | \"748\" | \"752\" | \"756\" | \"760\" | \"764\" | \"776\" | \"780\" | \"784\" | \"788\" | \"8\" | \"800\" | \"807\" | \"818\" | \"826\" | \"834\" | \"84\" | \"840\" | \"858\" | \"860\" | \"882\" | \"886\" | \"90\" | \"901\" | \"925\" | \"926\" | \"927\" | \"928\" | \"929\" | \"930\" | \"931\" | \"932\" | \"933\" | \"934\" | \"936\" | \"938\" | \"940\" | \"941\" | \"943\" | \"944\" | \"946\" | \"947\" | \"948\" | \"949\" | \"950\" | \"951\" | \"952\" | \"953\" | \"96\" | \"967\" | \"968\" | \"969\" | \"970\" | \"971\" | \"972\" | \"973\" | \"975\" | \"976\" | \"977\" | \"978\" | \"979\" | \"980\" | \"981\" | \"984\" | \"985\" | \"986\" | \"990\" | \"997\")",
+    value: input.isoNumber
+}, _errorFactory)) && (5 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every(key => {
+    if (["#private", "code", "name", "precision", "isoNumber"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return __typia_transform__assertGuard._assertGuard(_exceptionable, {
+        method: "createAssertEquals",
+        path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+        expected: "undefined",
+        value: value
+    }, _errorFactory);
+}))); const _ao3 = (input, _path, _exceptionable = true) => true && (1 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every(key => {
+    if (["#private"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return __typia_transform__assertGuard._assertGuard(_exceptionable, {
+        method: "createAssertEquals",
+        path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+        expected: "undefined",
+        value: value
+    }, _errorFactory);
+}))); const _ao4 = (input, _path, _exceptionable = true) => ("string" === typeof input.location && (RegExp(/^chain:keeta:[+-]?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/).test(input.location) || RegExp(/^chain:evm:[+-]?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/).test(input.location)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".location",
+    expected: "(`chain:evm:${bigint}` | `chain:keeta:${bigint}`)",
+    value: input.location
+}, _errorFactory)) && ("string" === typeof input.value || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".value",
+    expected: "string",
+    value: input.value
+}, _errorFactory)) && (("object" === typeof input.transactions && null !== input.transactions || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".transactions",
+    expected: "TransactionIds<\"persistentForwarding\" | \"deposit\" | \"finalization\">",
+    value: input.transactions
+}, _errorFactory)) && _ao5(input.transactions, _path + ".transactions", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".transactions",
+    expected: "TransactionIds<\"persistentForwarding\" | \"deposit\" | \"finalization\">",
+    value: input.transactions
+}, _errorFactory)) && (3 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every(key => {
+    if (["location", "value", "transactions"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return __typia_transform__assertGuard._assertGuard(_exceptionable, {
+        method: "createAssertEquals",
+        path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+        expected: "undefined",
+        value: value
+    }, _errorFactory);
+}))); const _ao5 = (input, _path, _exceptionable = true) => (null === input.persistentForwarding || ("object" === typeof input.persistentForwarding && null !== input.persistentForwarding || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".persistentForwarding",
+    expected: "(TransactionId | null)",
+    value: input.persistentForwarding
+}, _errorFactory)) && _ao6(input.persistentForwarding, _path + ".persistentForwarding", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".persistentForwarding",
+    expected: "(TransactionId | null)",
+    value: input.persistentForwarding
+}, _errorFactory)) && (null === input.deposit || ("object" === typeof input.deposit && null !== input.deposit || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".deposit",
+    expected: "(TransactionId | null)",
+    value: input.deposit
+}, _errorFactory)) && _ao6(input.deposit, _path + ".deposit", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".deposit",
+    expected: "(TransactionId | null)",
+    value: input.deposit
+}, _errorFactory)) && (null === input.finalization || ("object" === typeof input.finalization && null !== input.finalization || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".finalization",
+    expected: "(TransactionId | null)",
+    value: input.finalization
+}, _errorFactory)) && _ao6(input.finalization, _path + ".finalization", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".finalization",
+    expected: "(TransactionId | null)",
+    value: input.finalization
+}, _errorFactory)) && (3 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every(key => {
+    if (["persistentForwarding", "deposit", "finalization"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return __typia_transform__assertGuard._assertGuard(_exceptionable, {
+        method: "createAssertEquals",
+        path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+        expected: "undefined",
+        value: value
+    }, _errorFactory);
+}))); const _ao6 = (input, _path, _exceptionable = true) => ("string" === typeof input.id || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".id",
+    expected: "string",
+    value: input.id
+}, _errorFactory)) && ("string" === typeof input.nonce || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".nonce",
+    expected: "string",
+    value: input.nonce
+}, _errorFactory)) && (2 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every(key => {
+    if (["id", "nonce"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return __typia_transform__assertGuard._assertGuard(_exceptionable, {
+        method: "createAssertEquals",
+        path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+        expected: "undefined",
+        value: value
+    }, _errorFactory);
+}))); const _ao7 = (input, _path, _exceptionable = true) => ("string" === typeof input.location && (RegExp(/^chain:keeta:[+-]?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/).test(input.location) || RegExp(/^chain:evm:[+-]?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/).test(input.location)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".location",
+    expected: "(`chain:evm:${bigint}` | `chain:keeta:${bigint}`)",
+    value: input.location
+}, _errorFactory)) && ("string" === typeof input.value || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".value",
+    expected: "string",
+    value: input.value
+}, _errorFactory)) && (("object" === typeof input.transactions && null !== input.transactions || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".transactions",
+    expected: "TransactionIds<\"withdraw\">",
+    value: input.transactions
+}, _errorFactory)) && _ao8(input.transactions, _path + ".transactions", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".transactions",
+    expected: "TransactionIds<\"withdraw\">",
+    value: input.transactions
+}, _errorFactory)) && (3 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every(key => {
+    if (["location", "value", "transactions"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return __typia_transform__assertGuard._assertGuard(_exceptionable, {
+        method: "createAssertEquals",
+        path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+        expected: "undefined",
+        value: value
+    }, _errorFactory);
+}))); const _ao8 = (input, _path, _exceptionable = true) => (null === input.withdraw || ("object" === typeof input.withdraw && null !== input.withdraw || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".withdraw",
+    expected: "(TransactionId | null)",
+    value: input.withdraw
+}, _errorFactory)) && _ao6(input.withdraw, _path + ".withdraw", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".withdraw",
+    expected: "(TransactionId | null)",
+    value: input.withdraw
+}, _errorFactory)) && (1 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every(key => {
+    if (["withdraw"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return __typia_transform__assertGuard._assertGuard(_exceptionable, {
+        method: "createAssertEquals",
+        path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+        expected: "undefined",
+        value: value
+    }, _errorFactory);
+}))); const _ao9 = (input, _path, _exceptionable = true) => (null !== input.asset || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".asset",
+    expected: "(Currency | TokenAddress | `keeta_am${string}` | `keeta_an${string}` | `keeta_ao${string}` | `keeta_ap${string}` | `tyblocks_am${string}` | `tyblocks_an${string}` | `tyblocks_ao${string}` | `tyblocks_ap${string}`)",
+    value: input.asset
+}, _errorFactory)) && (undefined !== input.asset || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".asset",
+    expected: "(Currency | TokenAddress | `keeta_am${string}` | `keeta_an${string}` | `keeta_ao${string}` | `keeta_ap${string}` | `tyblocks_am${string}` | `tyblocks_an${string}` | `tyblocks_ao${string}` | `tyblocks_ap${string}`)",
+    value: input.asset
+}, _errorFactory)) && ("string" === typeof input.asset && (RegExp(/^keeta_am(.*)/).test(input.asset) || RegExp(/^keeta_an(.*)/).test(input.asset) || RegExp(/^keeta_ao(.*)/).test(input.asset) || RegExp(/^keeta_ap(.*)/).test(input.asset) || RegExp(/^tyblocks_am(.*)/).test(input.asset) || RegExp(/^tyblocks_an(.*)/).test(input.asset) || RegExp(/^tyblocks_ao(.*)/).test(input.asset) || RegExp(/^tyblocks_ap(.*)/).test(input.asset)) || ("object" === typeof input.asset && null !== input.asset || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".asset",
+    expected: "(Currency | TokenAddress | `keeta_am${string}` | `keeta_an${string}` | `keeta_ao${string}` | `keeta_ap${string}` | `tyblocks_am${string}` | `tyblocks_an${string}` | `tyblocks_ao${string}` | `tyblocks_ap${string}`)",
+    value: input.asset
+}, _errorFactory)) && _au0(input.asset, _path + ".asset", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".asset",
+    expected: "(Currency | TokenAddress | `keeta_am${string}` | `keeta_an${string}` | `keeta_ao${string}` | `keeta_ap${string}` | `tyblocks_am${string}` | `tyblocks_an${string}` | `tyblocks_ao${string}` | `tyblocks_ap${string}`)",
+    value: input.asset
+}, _errorFactory)) && ("string" === typeof input.value || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".value",
+    expected: "string",
+    value: input.value
+}, _errorFactory)) && (2 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every(key => {
+    if (["asset", "value"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return __typia_transform__assertGuard._assertGuard(_exceptionable, {
+        method: "createAssertEquals",
+        path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+        expected: "undefined",
+        value: value
+    }, _errorFactory);
+}))); const _ao10 = (input, _path, _exceptionable = true) => (false === input.ok || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".ok",
+    expected: "false",
+    value: input.ok
+}, _errorFactory)) && ("string" === typeof input.error || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssertEquals",
+    path: _path + ".error",
+    expected: "string",
+    value: input.error
+}, _errorFactory)) && (2 === Object.keys(input).length || (false === _exceptionable || Object.keys(input).every(key => {
+    if (["ok", "error"].some(prop => key === prop))
+        return true;
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return __typia_transform__assertGuard._assertGuard(_exceptionable, {
+        method: "createAssertEquals",
+        path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+        expected: "undefined",
+        value: value
+    }, _errorFactory);
+}))); const _au0 = (input, _path, _exceptionable = true) => (() => {
+    if (undefined !== input.code)
+        return _ao2(input, _path, true && _exceptionable);
+    else
+        return _ao3(input, _path, true && _exceptionable);
+})(); const _au1 = (input, _path, _exceptionable = true) => (() => {
+    if (true === input.ok)
+        return _ao0(input, _path, true && _exceptionable);
+    else if (false === input.ok)
+        return _ao10(input, _path, true && _exceptionable);
+    else
+        return __typia_transform__assertGuard._assertGuard(_exceptionable, {
+            method: "createAssertEquals",
+            path: _path,
+            expected: "({ ok: true; transactions: KeetaAssetMovementTransaction[]; } & PaginationResponseInformation | __type.o3)",
+            value: input
+        }, _errorFactory);
+})(); const __is = (input, _exceptionable = true) => "object" === typeof input && null !== input && _iu1(input, true); let _errorFactory; return (input, errorFactory) => {
+    if (false === __is(input)) {
+        _errorFactory = errorFactory;
+        ((input, _path, _exceptionable = true) => ("object" === typeof input && null !== input || __typia_transform__assertGuard._assertGuard(true, {
+            method: "createAssertEquals",
+            path: _path + "",
+            expected: "(__type.o3 | { ok: true; transactions: KeetaAssetMovementTransaction[]; } & PaginationResponseInformation)",
+            value: input
+        }, _errorFactory)) && _au1(input, _path + "", true) || __typia_transform__assertGuard._assertGuard(true, {
+            method: "createAssertEquals",
+            path: _path + "",
+            expected: "(__type.o3 | { ok: true; transactions: KeetaAssetMovementTransaction[]; } & PaginationResponseInformation)",
+            value: input
+        }, _errorFactory))(input, "$input", true);
+    }
+    return input;
+}; })();
+export const isKeetaAssetMovementAnchorCreatePersistentForwardingResponse = (() => { const _io0 = input => true === input.ok && "string" === typeof input.address; const _io1 = input => false === input.ok && "string" === typeof input.error; const _iu0 = input => (() => {
+    if (true === input.ok)
+        return _io0(input);
+    else if (false === input.ok)
+        return _io1(input);
+    else
+        return false;
+})(); return input => "object" === typeof input && null !== input && _iu0(input); })();
+export const isKeetaAssetMovementAnchorInitiateTransferResponse = (() => { const _io0 = input => true === input.ok && "string" === typeof input.id && (Array.isArray(input.instructionChoices) && input.instructionChoices.every(elem => "object" === typeof elem && null !== elem && _iu0(elem))); const _io1 = input => "KEETA_SEND" === input.type && (null !== input.location && undefined !== input.location && ("string" === typeof input.location && (RegExp(/^chain:keeta:[+-]?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/).test(input.location) || RegExp(/^chain:evm:[+-]?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/).test(input.location)) || "object" === typeof input.location && null !== input.location && _iu1(input.location))) && "string" === typeof input.sendToAddress && "string" === typeof input.value && "string" === typeof input.tokenAddress && (undefined === input.external || "string" === typeof input.external) && "string" === typeof input.assetFee; const _io2 = input => "chain" === input.type && ("object" === typeof input.chain && null !== input.chain && _iu2(input.chain)); const _io3 = input => "keeta" === input.type && "bigint" === typeof input.networkId; const _io4 = input => "evm" === input.type && "bigint" === typeof input.chainId; const _io5 = input => "bank-account" === input.type && (null !== input.workInProgress && undefined === input.workInProgress); const _io6 = input => "EVM_SEND" === input.type && (null !== input.location && undefined !== input.location && ("string" === typeof input.location && (RegExp(/^chain:keeta:[+-]?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/).test(input.location) || RegExp(/^chain:evm:[+-]?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/).test(input.location)) || "object" === typeof input.location && null !== input.location && _iu1(input.location))) && "string" === typeof input.sendToAddress && "string" === typeof input.value && ("string" === typeof input.tokenAddress && RegExp(/^0x(.*)/).test(input.tokenAddress)) && "string" === typeof input.assetFee; const _io7 = input => "EVM_CALL" === input.type && (null !== input.location && undefined !== input.location && ("string" === typeof input.location && (RegExp(/^chain:keeta:[+-]?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/).test(input.location) || RegExp(/^chain:evm:[+-]?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/).test(input.location)) || "object" === typeof input.location && null !== input.location && _iu1(input.location))) && "string" === typeof input.contractAddress && "string" === typeof input.contractMethodName && (Array.isArray(input.contractMethodArgs) && input.contractMethodArgs.every(elem => "string" === typeof elem)) && "string" === typeof input.assetFee; const _io8 = input => false === input.ok && "string" === typeof input.error; const _iu0 = input => (() => {
+    if ("KEETA_SEND" === input.type)
+        return _io1(input);
+    else if ("EVM_SEND" === input.type)
+        return _io6(input);
+    else if ("EVM_CALL" === input.type)
+        return _io7(input);
+    else
+        return false;
+})(); const _iu1 = input => (() => {
+    if ("chain" === input.type)
+        return _io2(input);
+    else if ("bank-account" === input.type)
+        return _io5(input);
+    else
+        return false;
+})(); const _iu2 = input => (() => {
+    if ("keeta" === input.type)
+        return _io3(input);
+    else if ("evm" === input.type)
+        return _io4(input);
+    else
+        return false;
+})(); const _iu3 = input => (() => {
+    if (true === input.ok)
+        return _io0(input);
+    else if (false === input.ok)
+        return _io8(input);
+    else
+        return false;
+})(); return input => "object" === typeof input && null !== input && _iu3(input); })();
+export const isKeetaAssetMovementAnchorGetExchangeStatusResponse = (() => { const _iv1 = new Set(["ALL", "AFN", "EUR", "DZD", "USD", "AOA", "XCD", "ARS", "AMD", "AWG", "AUD", "AZN", "BSD", "BHD", "BDT", "BBD", "BYN", "BZD", "XOF", "BMD", "INR", "BTN", "BOB", "BOV", "BAM", "BWP", "NOK", "BRL", "BND", "BGN", "BIF", "CVE", "KHR", "XAF", "CAD", "KYD", "CLP", "CLF", "CNY", "COP", "COU", "KMF", "CDF", "NZD", "CRC", "CUP", "CUC", "ANG", "CZK", "DKK", "DJF", "DOP", "EGP", "SVC", "ERN", "SZL", "ETB", "FKP", "FJD", "XPF", "GMD", "GEL", "GHS", "GIP", "GTQ", "GBP", "GNF", "GYD", "HTG", "HNL", "HKD", "HUF", "ISK", "IDR", "IRR", "IQD", "ILS", "JMD", "JPY", "JOD", "KZT", "KES", "KPW", "KRW", "KWD", "KGS", "LAK", "LBP", "LSL", "ZAR", "LRD", "LYD", "CHF", "MOP", "MKD", "MGA", "MWK", "MYR", "MVR", "MRU", "MUR", "MXN", "MXV", "MDL", "MNT", "MAD", "MZN", "MMK", "NAD", "NPR", "NIO", "NGN", "OMR", "PKR", "PAB", "PGK", "PYG", "PEN", "PHP", "PLN", "QAR", "RON", "RUB", "RWF", "SHP", "WST", "STN", "SAR", "RSD", "SCR", "SLL", "SLE", "SGD", "SBD", "SOS", "SSP", "LKR", "SDG", "SRD", "SEK", "CHE", "CHW", "SYP", "TWD", "TJS", "TZS", "THB", "TOP", "TTD", "TND", "TRY", "TMT", "UGX", "UAH", "AED", "USN", "UYU", "UYI", "UYW", "UZS", "VUV", "VES", "VED", "VND", "YER", "ZMW", "ZWL"]); const _iv2 = new Set(["971", "978", "8", "12", "840", "973", "951", "32", "51", "533", "36", "944", "44", "48", "50", "52", "933", "84", "952", "60", "356", "64", "68", "984", "977", "72", "578", "986", "96", "975", "108", "132", "116", "950", "124", "136", "152", "990", "156", "170", "970", "174", "976", "554", "188", "192", "931", "532", "203", "208", "262", "214", "818", "222", "232", "748", "230", "238", "242", "953", "270", "981", "936", "292", "320", "826", "324", "328", "332", "340", "344", "348", "352", "360", "364", "368", "376", "388", "392", "400", "398", "404", "408", "410", "414", "417", "418", "422", "426", "710", "430", "434", "756", "446", "807", "969", "454", "458", "462", "929", "480", "484", "979", "498", "496", "504", "943", "104", "516", "524", "558", "566", "512", "586", "590", "598", "600", "604", "608", "985", "634", "946", "643", "646", "654", "882", "930", "682", "941", "690", "694", "925", "702", "90", "706", "728", "144", "938", "968", "752", "947", "948", "760", "901", "972", "834", "764", "776", "780", "788", "949", "934", "800", "980", "784", "997", "858", "940", "927", "860", "548", "928", "926", "704", "886", "967", "932"]); const _io0 = input => true === input.ok && ("object" === typeof input.transaction && null !== input.transaction && _io1(input.transaction)); const _io1 = input => "string" === typeof input.id && "string" === typeof input.status && (null !== input.asset && undefined !== input.asset && ("string" === typeof input.asset && (RegExp(/^keeta_am(.*)/).test(input.asset) || RegExp(/^keeta_an(.*)/).test(input.asset) || RegExp(/^keeta_ao(.*)/).test(input.asset) || RegExp(/^keeta_ap(.*)/).test(input.asset) || RegExp(/^tyblocks_am(.*)/).test(input.asset) || RegExp(/^tyblocks_an(.*)/).test(input.asset) || RegExp(/^tyblocks_ao(.*)/).test(input.asset) || RegExp(/^tyblocks_ap(.*)/).test(input.asset)) || "object" === typeof input.asset && null !== input.asset && _iu0(input.asset))) && ("object" === typeof input.from && null !== input.from && _io4(input.from)) && ("object" === typeof input.to && null !== input.to && _io7(input.to)) && (null === input.fee || "object" === typeof input.fee && null !== input.fee && _io9(input.fee)) && "string" === typeof input.createdAt && "string" === typeof input.updatedAt; const _io2 = input => true && true === _iv1.has(input.code) && "string" === typeof input.name && "string" === typeof input.precision && true === _iv2.has(input.isoNumber); const _io3 = input => true; const _io4 = input => "string" === typeof input.location && (RegExp(/^chain:keeta:[+-]?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/).test(input.location) || RegExp(/^chain:evm:[+-]?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/).test(input.location)) && "string" === typeof input.value && ("object" === typeof input.transactions && null !== input.transactions && _io5(input.transactions)); const _io5 = input => (null === input.persistentForwarding || "object" === typeof input.persistentForwarding && null !== input.persistentForwarding && _io6(input.persistentForwarding)) && (null === input.deposit || "object" === typeof input.deposit && null !== input.deposit && _io6(input.deposit)) && (null === input.finalization || "object" === typeof input.finalization && null !== input.finalization && _io6(input.finalization)); const _io6 = input => "string" === typeof input.id && "string" === typeof input.nonce; const _io7 = input => "string" === typeof input.location && (RegExp(/^chain:keeta:[+-]?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/).test(input.location) || RegExp(/^chain:evm:[+-]?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/).test(input.location)) && "string" === typeof input.value && ("object" === typeof input.transactions && null !== input.transactions && _io8(input.transactions)); const _io8 = input => null === input.withdraw || "object" === typeof input.withdraw && null !== input.withdraw && _io6(input.withdraw); const _io9 = input => null !== input.asset && undefined !== input.asset && ("string" === typeof input.asset && (RegExp(/^keeta_am(.*)/).test(input.asset) || RegExp(/^keeta_an(.*)/).test(input.asset) || RegExp(/^keeta_ao(.*)/).test(input.asset) || RegExp(/^keeta_ap(.*)/).test(input.asset) || RegExp(/^tyblocks_am(.*)/).test(input.asset) || RegExp(/^tyblocks_an(.*)/).test(input.asset) || RegExp(/^tyblocks_ao(.*)/).test(input.asset) || RegExp(/^tyblocks_ap(.*)/).test(input.asset)) || "object" === typeof input.asset && null !== input.asset && _iu0(input.asset)) && "string" === typeof input.value; const _io10 = input => false === input.ok && "string" === typeof input.error; const _iu0 = input => (() => {
+    if (undefined !== input.code)
+        return _io2(input);
+    else
+        return _io3(input);
+})(); const _iu1 = input => (() => {
+    if (true === input.ok)
+        return _io0(input);
+    else if (false === input.ok)
+        return _io10(input);
+    else
+        return false;
+})(); return input => "object" === typeof input && null !== input && _iu1(input); })();
+export const isKeetaAssetMovementAnchorlistPersistentForwardingTransactionsResponse = (() => { const _iv2 = new Set(["ALL", "AFN", "EUR", "DZD", "USD", "AOA", "XCD", "ARS", "AMD", "AWG", "AUD", "AZN", "BSD", "BHD", "BDT", "BBD", "BYN", "BZD", "XOF", "BMD", "INR", "BTN", "BOB", "BOV", "BAM", "BWP", "NOK", "BRL", "BND", "BGN", "BIF", "CVE", "KHR", "XAF", "CAD", "KYD", "CLP", "CLF", "CNY", "COP", "COU", "KMF", "CDF", "NZD", "CRC", "CUP", "CUC", "ANG", "CZK", "DKK", "DJF", "DOP", "EGP", "SVC", "ERN", "SZL", "ETB", "FKP", "FJD", "XPF", "GMD", "GEL", "GHS", "GIP", "GTQ", "GBP", "GNF", "GYD", "HTG", "HNL", "HKD", "HUF", "ISK", "IDR", "IRR", "IQD", "ILS", "JMD", "JPY", "JOD", "KZT", "KES", "KPW", "KRW", "KWD", "KGS", "LAK", "LBP", "LSL", "ZAR", "LRD", "LYD", "CHF", "MOP", "MKD", "MGA", "MWK", "MYR", "MVR", "MRU", "MUR", "MXN", "MXV", "MDL", "MNT", "MAD", "MZN", "MMK", "NAD", "NPR", "NIO", "NGN", "OMR", "PKR", "PAB", "PGK", "PYG", "PEN", "PHP", "PLN", "QAR", "RON", "RUB", "RWF", "SHP", "WST", "STN", "SAR", "RSD", "SCR", "SLL", "SLE", "SGD", "SBD", "SOS", "SSP", "LKR", "SDG", "SRD", "SEK", "CHE", "CHW", "SYP", "TWD", "TJS", "TZS", "THB", "TOP", "TTD", "TND", "TRY", "TMT", "UGX", "UAH", "AED", "USN", "UYU", "UYI", "UYW", "UZS", "VUV", "VES", "VED", "VND", "YER", "ZMW", "ZWL"]); const _iv3 = new Set(["971", "978", "8", "12", "840", "973", "951", "32", "51", "533", "36", "944", "44", "48", "50", "52", "933", "84", "952", "60", "356", "64", "68", "984", "977", "72", "578", "986", "96", "975", "108", "132", "116", "950", "124", "136", "152", "990", "156", "170", "970", "174", "976", "554", "188", "192", "931", "532", "203", "208", "262", "214", "818", "222", "232", "748", "230", "238", "242", "953", "270", "981", "936", "292", "320", "826", "324", "328", "332", "340", "344", "348", "352", "360", "364", "368", "376", "388", "392", "400", "398", "404", "408", "410", "414", "417", "418", "422", "426", "710", "430", "434", "756", "446", "807", "969", "454", "458", "462", "929", "480", "484", "979", "498", "496", "504", "943", "104", "516", "524", "558", "566", "512", "586", "590", "598", "600", "604", "608", "985", "634", "946", "643", "646", "654", "882", "930", "682", "941", "690", "694", "925", "702", "90", "706", "728", "144", "938", "968", "752", "947", "948", "760", "901", "972", "834", "764", "776", "780", "788", "949", "934", "800", "980", "784", "997", "858", "940", "927", "860", "548", "928", "926", "704", "886", "967", "932"]); const _io0 = input => true === input.ok && (Array.isArray(input.transactions) && input.transactions.every(elem => "object" === typeof elem && null !== elem && _io1(elem))) && "string" === typeof input.total; const _io1 = input => "string" === typeof input.id && "string" === typeof input.status && (null !== input.asset && undefined !== input.asset && ("string" === typeof input.asset && (RegExp(/^keeta_am(.*)/).test(input.asset) || RegExp(/^keeta_an(.*)/).test(input.asset) || RegExp(/^keeta_ao(.*)/).test(input.asset) || RegExp(/^keeta_ap(.*)/).test(input.asset) || RegExp(/^tyblocks_am(.*)/).test(input.asset) || RegExp(/^tyblocks_an(.*)/).test(input.asset) || RegExp(/^tyblocks_ao(.*)/).test(input.asset) || RegExp(/^tyblocks_ap(.*)/).test(input.asset)) || "object" === typeof input.asset && null !== input.asset && _iu0(input.asset))) && ("object" === typeof input.from && null !== input.from && _io4(input.from)) && ("object" === typeof input.to && null !== input.to && _io7(input.to)) && (null === input.fee || "object" === typeof input.fee && null !== input.fee && _io9(input.fee)) && "string" === typeof input.createdAt && "string" === typeof input.updatedAt; const _io2 = input => true && true === _iv2.has(input.code) && "string" === typeof input.name && "string" === typeof input.precision && true === _iv3.has(input.isoNumber); const _io3 = input => true; const _io4 = input => "string" === typeof input.location && (RegExp(/^chain:keeta:[+-]?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/).test(input.location) || RegExp(/^chain:evm:[+-]?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/).test(input.location)) && "string" === typeof input.value && ("object" === typeof input.transactions && null !== input.transactions && _io5(input.transactions)); const _io5 = input => (null === input.persistentForwarding || "object" === typeof input.persistentForwarding && null !== input.persistentForwarding && _io6(input.persistentForwarding)) && (null === input.deposit || "object" === typeof input.deposit && null !== input.deposit && _io6(input.deposit)) && (null === input.finalization || "object" === typeof input.finalization && null !== input.finalization && _io6(input.finalization)); const _io6 = input => "string" === typeof input.id && "string" === typeof input.nonce; const _io7 = input => "string" === typeof input.location && (RegExp(/^chain:keeta:[+-]?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/).test(input.location) || RegExp(/^chain:evm:[+-]?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?$/).test(input.location)) && "string" === typeof input.value && ("object" === typeof input.transactions && null !== input.transactions && _io8(input.transactions)); const _io8 = input => null === input.withdraw || "object" === typeof input.withdraw && null !== input.withdraw && _io6(input.withdraw); const _io9 = input => null !== input.asset && undefined !== input.asset && ("string" === typeof input.asset && (RegExp(/^keeta_am(.*)/).test(input.asset) || RegExp(/^keeta_an(.*)/).test(input.asset) || RegExp(/^keeta_ao(.*)/).test(input.asset) || RegExp(/^keeta_ap(.*)/).test(input.asset) || RegExp(/^tyblocks_am(.*)/).test(input.asset) || RegExp(/^tyblocks_an(.*)/).test(input.asset) || RegExp(/^tyblocks_ao(.*)/).test(input.asset) || RegExp(/^tyblocks_ap(.*)/).test(input.asset)) || "object" === typeof input.asset && null !== input.asset && _iu0(input.asset)) && "string" === typeof input.value; const _io10 = input => false === input.ok && "string" === typeof input.error; const _iu0 = input => (() => {
+    if (undefined !== input.code)
+        return _io2(input);
+    else
+        return _io3(input);
+})(); const _iu1 = input => (() => {
+    if (true === input.ok)
+        return _io0(input);
+    else if (false === input.ok)
+        return _io10(input);
+    else
+        return false;
+})(); return input => "object" === typeof input && null !== input && _iu1(input); })();
+//# sourceMappingURL=common.js.map