@keetanetwork/anchor 0.0.1

package/lib/resolver.js

@@ -0,0 +1,1429 @@
+import * as __typia_transform__assertGuard from "typia/lib/internal/_assertGuard.js";
+import * as __typia_transform__accessExpressionAsString from "typia/lib/internal/_accessExpressionAsString.js";
+import * as KeetaNetClient from '@keetanetwork/keetanet-client';
+import CurrencyInfo from '@keetanetwork/currency-info';
+import { assertNever } from './utils/never.js';
+import { Buffer } from './utils/buffer.js';
+import crypto from './utils/crypto.js';
+import { createIs, createAssert } from 'typia';
+function convertToCurrencySearchCanonical(input) {
+    if (CurrencyInfo.Currency.isCurrencyCode(input)) {
+        return (input);
+    }
+    else if (CurrencyInfo.Currency.isISOCurrencyNumber(input)) {
+        input = new CurrencyInfo.Currency(input);
+    }
+    return (input.code);
+}
+function convertToCountrySearchCanonical(input) {
+    if (CurrencyInfo.Country.isCountryCode(input)) {
+        return (input);
+    }
+    else if (CurrencyInfo.Country.isISOCountryNumber(input)) {
+        input = new CurrencyInfo.Country(input);
+    }
+    return (input.code);
+}
+/**
+ * Check if a value is an ExternalURL
+ */
+const isExternalURL = (() => { const _io0 = input => "2b828e33-2692-46e9-817e-9b93d63f28fd" === input.external && "string" === typeof input.url; return input => "object" === typeof input && null !== input && _io0(input); })();
+;
+;
+;
+;
+/*
+ * Access token to share with the Metadata object to allow it to
+ * access the mutable stats object.
+ */
+const statsAccessToken = Symbol('statsAccessToken');
+const assertServiceMetadata = (() => { const _io0 = input => "2b828e33-2692-46e9-817e-9b93d63f28fd" === input.external && "string" === typeof input.url; const _io1 = input => null !== input.version && undefined !== input.version && ("number" === typeof input.version || "object" === typeof input.version && null !== input.version && _io0(input.version)) && ("object" === typeof input.services && null !== input.services && false === Array.isArray(input.services) && _iu1(input.services)); const _io2 = input => (undefined === input.banking || "object" === typeof input.banking && null !== input.banking && false === Array.isArray(input.banking) && _iu2(input.banking)) && (undefined === input.kyc || "object" === typeof input.kyc && null !== input.kyc && false === Array.isArray(input.kyc) && _iu3(input.kyc)) && (undefined === input.fx || "object" === typeof input.fx && null !== input.fx && _iu4(input.fx)) && (undefined === input.inbound || "object" === typeof input.inbound && null !== input.inbound && false === Array.isArray(input.inbound) && _iu5(input.inbound)) && (undefined === input.outbound || "object" === typeof input.outbound && null !== input.outbound && false === Array.isArray(input.outbound) && _iu6(input.outbound)) && (undefined === input.cards || "object" === typeof input.cards && null !== input.cards && false === Array.isArray(input.cards) && _iu7(input.cards)); const _io3 = input => Object.keys(input).every(key => {
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return "object" === typeof value && null !== value && _iu8(value);
+}); const _io4 = input => "object" === typeof input.operations && null !== input.operations && false === Array.isArray(input.operations) && _iu9(input.operations) && (null !== input.currencyCodes && undefined !== input.currencyCodes && (Array.isArray(input.currencyCodes) && input.currencyCodes.every(elem => null !== elem && undefined !== elem && ("string" === typeof elem || "object" === typeof elem && null !== elem && _io0(elem))) || "object" === typeof input.currencyCodes && null !== input.currencyCodes && _io0(input.currencyCodes))) && (null !== input.countryCodes && undefined !== input.countryCodes && (Array.isArray(input.countryCodes) && input.countryCodes.every(elem => null !== elem && undefined !== elem && ("string" === typeof elem || "object" === typeof elem && null !== elem && _io0(elem))) || "object" === typeof input.countryCodes && null !== input.countryCodes && _io0(input.countryCodes))) && (null !== input.kycProviders && (undefined === input.kycProviders || (Array.isArray(input.kycProviders) && input.kycProviders.every(elem => null !== elem && undefined !== elem && ("string" === typeof elem || "object" === typeof elem && null !== elem && _io0(elem))) || "object" === typeof input.kycProviders && null !== input.kycProviders && _io0(input.kycProviders)))); const _io5 = input => null !== input.createAccount && (undefined === input.createAccount || "string" === typeof input.createAccount || "object" === typeof input.createAccount && null !== input.createAccount && _io0(input.createAccount)); const _io6 = input => Object.keys(input).every(key => {
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return "object" === typeof value && null !== value && _iu10(value);
+}); const _io7 = input => "object" === typeof input.operations && null !== input.operations && false === Array.isArray(input.operations) && _iu11(input.operations) && (null !== input.countryCodes && (undefined === input.countryCodes || (Array.isArray(input.countryCodes) && input.countryCodes.every(elem => null !== elem && undefined !== elem && ("string" === typeof elem || "object" === typeof elem && null !== elem && _io0(elem))) || "object" === typeof input.countryCodes && null !== input.countryCodes && _io0(input.countryCodes)))) && (null !== input.ca && undefined !== input.ca && ("string" === typeof input.ca || "object" === typeof input.ca && null !== input.ca && _io0(input.ca))); const _io8 = input => null !== input.checkLocality && (undefined === input.checkLocality || "string" === typeof input.checkLocality || "object" === typeof input.checkLocality && null !== input.checkLocality && _io0(input.checkLocality)) && (null !== input.getEstimate && (undefined === input.getEstimate || "string" === typeof input.getEstimate || "object" === typeof input.getEstimate && null !== input.getEstimate && _io0(input.getEstimate))) && (null !== input.createVerification && (undefined === input.createVerification || "string" === typeof input.createVerification || "object" === typeof input.createVerification && null !== input.createVerification && _io0(input.createVerification))) && (null !== input.getCertificates && (undefined === input.getCertificates || "string" === typeof input.getCertificates || "object" === typeof input.getCertificates && null !== input.getCertificates && _io0(input.getCertificates))); const _io9 = input => null !== input.inputCurrencyCodes && undefined !== input.inputCurrencyCodes && (Array.isArray(input.inputCurrencyCodes) && input.inputCurrencyCodes.every(elem => "object" === typeof elem && null !== elem && _iu0(elem)) || "object" === typeof input.inputCurrencyCodes && null !== input.inputCurrencyCodes && _io0(input.inputCurrencyCodes)); const _io10 = input => null !== input.outputCurrencyCodes && undefined !== input.outputCurrencyCodes && (Array.isArray(input.outputCurrencyCodes) && input.outputCurrencyCodes.every(elem => null !== elem && undefined !== elem && ("string" === typeof elem || "object" === typeof elem && null !== elem && _io0(elem))) || "object" === typeof input.outputCurrencyCodes && null !== input.outputCurrencyCodes && _io0(input.outputCurrencyCodes)) && (null !== input.kycProviders && undefined !== input.kycProviders && (Array.isArray(input.kycProviders) && input.kycProviders.every(elem => null !== elem && undefined !== elem && ("string" === typeof elem || "object" === typeof elem && null !== elem && _io0(elem))) || "object" === typeof input.kycProviders && null !== input.kycProviders && _io0(input.kycProviders))); const _io11 = input => null !== input.workInProgress && (undefined === input.workInProgress || true === input.workInProgress || "object" === typeof input.workInProgress && null !== input.workInProgress && _io0(input.workInProgress)); const _io12 = input => null !== input.workInProgress && (undefined === input.workInProgress || true === input.workInProgress || "object" === typeof input.workInProgress && null !== input.workInProgress && _io0(input.workInProgress)); const _io13 = input => null !== input.workInProgress && (undefined === input.workInProgress || true === input.workInProgress || "object" === typeof input.workInProgress && null !== input.workInProgress && _io0(input.workInProgress)); const _iu0 = input => (() => {
+    if (undefined !== input.external)
+        return _io0(input);
+    else if (undefined !== input.outputCurrencyCodes)
+        return _io10(input);
+    else
+        return false;
+})(); const _iu1 = input => (() => {
+    if (undefined !== input.external)
+        return _io0(input);
+    else
+        return _io2(input);
+})(); const _iu2 = input => (() => {
+    if (undefined !== input.external)
+        return _io0(input);
+    else
+        return _io3(input);
+})(); const _iu3 = input => (() => {
+    if (undefined !== input.external)
+        return _io0(input);
+    else
+        return _io6(input);
+})(); const _iu4 = input => (() => {
+    if (undefined !== input.external)
+        return _io0(input);
+    else if (undefined !== input.inputCurrencyCodes)
+        return _io9(input);
+    else
+        return false;
+})(); const _iu5 = input => (() => {
+    if (undefined !== input.external)
+        return _io0(input);
+    else
+        return _io11(input);
+})(); const _iu6 = input => (() => {
+    if (undefined !== input.external)
+        return _io0(input);
+    else
+        return _io12(input);
+})(); const _iu7 = input => (() => {
+    if (undefined !== input.external)
+        return _io0(input);
+    else
+        return _io13(input);
+})(); const _iu8 = input => (() => {
+    if (undefined !== input.external)
+        return _io0(input);
+    else if (undefined !== input.operations)
+        return _io4(input);
+    else
+        return false;
+})(); const _iu9 = input => (() => {
+    if (undefined !== input.external)
+        return _io0(input);
+    else
+        return _io5(input);
+})(); const _iu10 = input => (() => {
+    if (undefined !== input.external)
+        return _io0(input);
+    else if (undefined !== input.operations)
+        return _io7(input);
+    else
+        return false;
+})(); const _iu11 = input => (() => {
+    if (undefined !== input.external)
+        return _io0(input);
+    else
+        return _io8(input);
+})(); const _iu12 = input => (() => {
+    if (undefined !== input.external)
+        return _io0(input);
+    else if (undefined !== input.version)
+        return _io1(input);
+    else
+        return false;
+})(); const _ao0 = (input, _path, _exceptionable = true) => ("2b828e33-2692-46e9-817e-9b93d63f28fd" === input.external || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".external",
+    expected: "\"2b828e33-2692-46e9-817e-9b93d63f28fd\"",
+    value: input.external
+}, _errorFactory)) && ("string" === typeof input.url || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".url",
+    expected: "string",
+    value: input.url
+}, _errorFactory)); const _ao1 = (input, _path, _exceptionable = true) => (null !== input.version || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".version",
+    expected: "(ExternalURL | number)",
+    value: input.version
+}, _errorFactory)) && (undefined !== input.version || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".version",
+    expected: "(ExternalURL | number)",
+    value: input.version
+}, _errorFactory)) && ("number" === typeof input.version || ("object" === typeof input.version && null !== input.version || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".version",
+    expected: "(ExternalURL | number)",
+    value: input.version
+}, _errorFactory)) && _ao0(input.version, _path + ".version", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".version",
+    expected: "(ExternalURL | number)",
+    value: input.version
+}, _errorFactory)) && (("object" === typeof input.services && null !== input.services && false === Array.isArray(input.services) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".services",
+    expected: "(ExternalURL | ToJSONValuizableObject<__type>)",
+    value: input.services
+}, _errorFactory)) && _au1(input.services, _path + ".services", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".services",
+    expected: "(ExternalURL | ToJSONValuizableObject<__type>)",
+    value: input.services
+}, _errorFactory)); const _ao2 = (input, _path, _exceptionable = true) => (undefined === input.banking || ("object" === typeof input.banking && null !== input.banking && false === Array.isArray(input.banking) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".banking",
+    expected: "(ExternalURL | ToJSONValuizableObject<__type>.o1 | undefined)",
+    value: input.banking
+}, _errorFactory)) && _au2(input.banking, _path + ".banking", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".banking",
+    expected: "(ExternalURL | ToJSONValuizableObject<__type>.o1 | undefined)",
+    value: input.banking
+}, _errorFactory)) && (undefined === input.kyc || ("object" === typeof input.kyc && null !== input.kyc && false === Array.isArray(input.kyc) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".kyc",
+    expected: "(ExternalURL | ToJSONValuizableObject<__type>.o4 | undefined)",
+    value: input.kyc
+}, _errorFactory)) && _au3(input.kyc, _path + ".kyc", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".kyc",
+    expected: "(ExternalURL | ToJSONValuizableObject<__type>.o4 | undefined)",
+    value: input.kyc
+}, _errorFactory)) && (undefined === input.fx || ("object" === typeof input.fx && null !== input.fx || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".fx",
+    expected: "(ExternalURL | ToJSONValuizableObject<__type>.o7 | undefined)",
+    value: input.fx
+}, _errorFactory)) && _au4(input.fx, _path + ".fx", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".fx",
+    expected: "(ExternalURL | ToJSONValuizableObject<__type>.o7 | undefined)",
+    value: input.fx
+}, _errorFactory)) && (undefined === input.inbound || ("object" === typeof input.inbound && null !== input.inbound && false === Array.isArray(input.inbound) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".inbound",
+    expected: "(ExternalURL | ToJSONValuizableObject<__type>.o9 | undefined)",
+    value: input.inbound
+}, _errorFactory)) && _au5(input.inbound, _path + ".inbound", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".inbound",
+    expected: "(ExternalURL | ToJSONValuizableObject<__type>.o9 | undefined)",
+    value: input.inbound
+}, _errorFactory)) && (undefined === input.outbound || ("object" === typeof input.outbound && null !== input.outbound && false === Array.isArray(input.outbound) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".outbound",
+    expected: "(ExternalURL | ToJSONValuizableObject<__type>.o10 | undefined)",
+    value: input.outbound
+}, _errorFactory)) && _au6(input.outbound, _path + ".outbound", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".outbound",
+    expected: "(ExternalURL | ToJSONValuizableObject<__type>.o10 | undefined)",
+    value: input.outbound
+}, _errorFactory)) && (undefined === input.cards || ("object" === typeof input.cards && null !== input.cards && false === Array.isArray(input.cards) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".cards",
+    expected: "(ExternalURL | ToJSONValuizableObject<__type>.o11 | undefined)",
+    value: input.cards
+}, _errorFactory)) && _au7(input.cards, _path + ".cards", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".cards",
+    expected: "(ExternalURL | ToJSONValuizableObject<__type>.o11 | undefined)",
+    value: input.cards
+}, _errorFactory)); const _ao3 = (input, _path, _exceptionable = true) => false === _exceptionable || Object.keys(input).every(key => {
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return ("object" === typeof value && null !== value || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+        method: "createAssert",
+        path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+        expected: "(ExternalURL | ToJSONValuizableObject<__type>.o2)",
+        value: value
+    }, _errorFactory)) && _au8(value, _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key), true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+        method: "createAssert",
+        path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+        expected: "(ExternalURL | ToJSONValuizableObject<__type>.o2)",
+        value: value
+    }, _errorFactory);
+}); const _ao4 = (input, _path, _exceptionable = true) => (("object" === typeof input.operations && null !== input.operations && false === Array.isArray(input.operations) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".operations",
+    expected: "(ExternalURL | ToJSONValuizableObject<__type>.o3)",
+    value: input.operations
+}, _errorFactory)) && _au9(input.operations, _path + ".operations", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".operations",
+    expected: "(ExternalURL | ToJSONValuizableObject<__type>.o3)",
+    value: input.operations
+}, _errorFactory)) && ((null !== input.currencyCodes || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".currencyCodes",
+    expected: "(Array<string | ExternalURL> | ExternalURL)",
+    value: input.currencyCodes
+}, _errorFactory)) && (undefined !== input.currencyCodes || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".currencyCodes",
+    expected: "(Array<string | ExternalURL> | ExternalURL)",
+    value: input.currencyCodes
+}, _errorFactory)) && (Array.isArray(input.currencyCodes) && input.currencyCodes.every((elem, _index8) => (null !== elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".currencyCodes[" + _index8 + "]",
+    expected: "(ExternalURL | string)",
+    value: elem
+}, _errorFactory)) && (undefined !== elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".currencyCodes[" + _index8 + "]",
+    expected: "(ExternalURL | string)",
+    value: elem
+}, _errorFactory)) && ("string" === typeof elem || ("object" === typeof elem && null !== elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".currencyCodes[" + _index8 + "]",
+    expected: "(ExternalURL | string)",
+    value: elem
+}, _errorFactory)) && _ao0(elem, _path + ".currencyCodes[" + _index8 + "]", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".currencyCodes[" + _index8 + "]",
+    expected: "(ExternalURL | string)",
+    value: elem
+}, _errorFactory))) || "object" === typeof input.currencyCodes && null !== input.currencyCodes && _ao0(input.currencyCodes, _path + ".currencyCodes", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".currencyCodes",
+    expected: "(Array<string | ExternalURL> | ExternalURL)",
+    value: input.currencyCodes
+}, _errorFactory) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".currencyCodes",
+    expected: "(Array<string | ExternalURL> | ExternalURL)",
+    value: input.currencyCodes
+}, _errorFactory))) && ((null !== input.countryCodes || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".countryCodes",
+    expected: "(Array<string | ExternalURL> | ExternalURL)",
+    value: input.countryCodes
+}, _errorFactory)) && (undefined !== input.countryCodes || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".countryCodes",
+    expected: "(Array<string | ExternalURL> | ExternalURL)",
+    value: input.countryCodes
+}, _errorFactory)) && (Array.isArray(input.countryCodes) && input.countryCodes.every((elem, _index9) => (null !== elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".countryCodes[" + _index9 + "]",
+    expected: "(ExternalURL | string)",
+    value: elem
+}, _errorFactory)) && (undefined !== elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".countryCodes[" + _index9 + "]",
+    expected: "(ExternalURL | string)",
+    value: elem
+}, _errorFactory)) && ("string" === typeof elem || ("object" === typeof elem && null !== elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".countryCodes[" + _index9 + "]",
+    expected: "(ExternalURL | string)",
+    value: elem
+}, _errorFactory)) && _ao0(elem, _path + ".countryCodes[" + _index9 + "]", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".countryCodes[" + _index9 + "]",
+    expected: "(ExternalURL | string)",
+    value: elem
+}, _errorFactory))) || "object" === typeof input.countryCodes && null !== input.countryCodes && _ao0(input.countryCodes, _path + ".countryCodes", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".countryCodes",
+    expected: "(Array<string | ExternalURL> | ExternalURL)",
+    value: input.countryCodes
+}, _errorFactory) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".countryCodes",
+    expected: "(Array<string | ExternalURL> | ExternalURL)",
+    value: input.countryCodes
+}, _errorFactory))) && ((null !== input.kycProviders || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".kycProviders",
+    expected: "(Array<string | ExternalURL> | ExternalURL | undefined)",
+    value: input.kycProviders
+}, _errorFactory)) && (undefined === input.kycProviders || (Array.isArray(input.kycProviders) && input.kycProviders.every((elem, _index10) => (null !== elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".kycProviders[" + _index10 + "]",
+    expected: "(ExternalURL | string)",
+    value: elem
+}, _errorFactory)) && (undefined !== elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".kycProviders[" + _index10 + "]",
+    expected: "(ExternalURL | string)",
+    value: elem
+}, _errorFactory)) && ("string" === typeof elem || ("object" === typeof elem && null !== elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".kycProviders[" + _index10 + "]",
+    expected: "(ExternalURL | string)",
+    value: elem
+}, _errorFactory)) && _ao0(elem, _path + ".kycProviders[" + _index10 + "]", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".kycProviders[" + _index10 + "]",
+    expected: "(ExternalURL | string)",
+    value: elem
+}, _errorFactory))) || "object" === typeof input.kycProviders && null !== input.kycProviders && _ao0(input.kycProviders, _path + ".kycProviders", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".kycProviders",
+    expected: "(Array<string | ExternalURL> | ExternalURL | undefined)",
+    value: input.kycProviders
+}, _errorFactory)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".kycProviders",
+    expected: "(Array<string | ExternalURL> | ExternalURL | undefined)",
+    value: input.kycProviders
+}, _errorFactory))); const _ao5 = (input, _path, _exceptionable = true) => (null !== input.createAccount || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".createAccount",
+    expected: "(ExternalURL | string | undefined)",
+    value: input.createAccount
+}, _errorFactory)) && (undefined === input.createAccount || "string" === typeof input.createAccount || ("object" === typeof input.createAccount && null !== input.createAccount || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".createAccount",
+    expected: "(ExternalURL | string | undefined)",
+    value: input.createAccount
+}, _errorFactory)) && _ao0(input.createAccount, _path + ".createAccount", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".createAccount",
+    expected: "(ExternalURL | string | undefined)",
+    value: input.createAccount
+}, _errorFactory)); const _ao6 = (input, _path, _exceptionable = true) => false === _exceptionable || Object.keys(input).every(key => {
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return ("object" === typeof value && null !== value || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+        method: "createAssert",
+        path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+        expected: "(ExternalURL | ToJSONValuizableObject<__type>.o5)",
+        value: value
+    }, _errorFactory)) && _au10(value, _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key), true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+        method: "createAssert",
+        path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+        expected: "(ExternalURL | ToJSONValuizableObject<__type>.o5)",
+        value: value
+    }, _errorFactory);
+}); const _ao7 = (input, _path, _exceptionable = true) => (("object" === typeof input.operations && null !== input.operations && false === Array.isArray(input.operations) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".operations",
+    expected: "(ExternalURL | ToJSONValuizableObject<__type>.o6)",
+    value: input.operations
+}, _errorFactory)) && _au11(input.operations, _path + ".operations", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".operations",
+    expected: "(ExternalURL | ToJSONValuizableObject<__type>.o6)",
+    value: input.operations
+}, _errorFactory)) && ((null !== input.countryCodes || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".countryCodes",
+    expected: "(Array<string | ExternalURL> | ExternalURL | undefined)",
+    value: input.countryCodes
+}, _errorFactory)) && (undefined === input.countryCodes || (Array.isArray(input.countryCodes) && input.countryCodes.every((elem, _index11) => (null !== elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".countryCodes[" + _index11 + "]",
+    expected: "(ExternalURL | string)",
+    value: elem
+}, _errorFactory)) && (undefined !== elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".countryCodes[" + _index11 + "]",
+    expected: "(ExternalURL | string)",
+    value: elem
+}, _errorFactory)) && ("string" === typeof elem || ("object" === typeof elem && null !== elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".countryCodes[" + _index11 + "]",
+    expected: "(ExternalURL | string)",
+    value: elem
+}, _errorFactory)) && _ao0(elem, _path + ".countryCodes[" + _index11 + "]", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".countryCodes[" + _index11 + "]",
+    expected: "(ExternalURL | string)",
+    value: elem
+}, _errorFactory))) || "object" === typeof input.countryCodes && null !== input.countryCodes && _ao0(input.countryCodes, _path + ".countryCodes", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".countryCodes",
+    expected: "(Array<string | ExternalURL> | ExternalURL | undefined)",
+    value: input.countryCodes
+}, _errorFactory)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".countryCodes",
+    expected: "(Array<string | ExternalURL> | ExternalURL | undefined)",
+    value: input.countryCodes
+}, _errorFactory))) && ((null !== input.ca || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".ca",
+    expected: "(ExternalURL | string)",
+    value: input.ca
+}, _errorFactory)) && (undefined !== input.ca || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".ca",
+    expected: "(ExternalURL | string)",
+    value: input.ca
+}, _errorFactory)) && ("string" === typeof input.ca || ("object" === typeof input.ca && null !== input.ca || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".ca",
+    expected: "(ExternalURL | string)",
+    value: input.ca
+}, _errorFactory)) && _ao0(input.ca, _path + ".ca", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".ca",
+    expected: "(ExternalURL | string)",
+    value: input.ca
+}, _errorFactory))); const _ao8 = (input, _path, _exceptionable = true) => (null !== input.checkLocality || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".checkLocality",
+    expected: "(ExternalURL | string | undefined)",
+    value: input.checkLocality
+}, _errorFactory)) && (undefined === input.checkLocality || "string" === typeof input.checkLocality || ("object" === typeof input.checkLocality && null !== input.checkLocality || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".checkLocality",
+    expected: "(ExternalURL | string | undefined)",
+    value: input.checkLocality
+}, _errorFactory)) && _ao0(input.checkLocality, _path + ".checkLocality", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".checkLocality",
+    expected: "(ExternalURL | string | undefined)",
+    value: input.checkLocality
+}, _errorFactory)) && ((null !== input.getEstimate || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".getEstimate",
+    expected: "(ExternalURL | string | undefined)",
+    value: input.getEstimate
+}, _errorFactory)) && (undefined === input.getEstimate || "string" === typeof input.getEstimate || ("object" === typeof input.getEstimate && null !== input.getEstimate || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".getEstimate",
+    expected: "(ExternalURL | string | undefined)",
+    value: input.getEstimate
+}, _errorFactory)) && _ao0(input.getEstimate, _path + ".getEstimate", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".getEstimate",
+    expected: "(ExternalURL | string | undefined)",
+    value: input.getEstimate
+}, _errorFactory))) && ((null !== input.createVerification || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".createVerification",
+    expected: "(ExternalURL | string | undefined)",
+    value: input.createVerification
+}, _errorFactory)) && (undefined === input.createVerification || "string" === typeof input.createVerification || ("object" === typeof input.createVerification && null !== input.createVerification || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".createVerification",
+    expected: "(ExternalURL | string | undefined)",
+    value: input.createVerification
+}, _errorFactory)) && _ao0(input.createVerification, _path + ".createVerification", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".createVerification",
+    expected: "(ExternalURL | string | undefined)",
+    value: input.createVerification
+}, _errorFactory))) && ((null !== input.getCertificates || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".getCertificates",
+    expected: "(ExternalURL | string | undefined)",
+    value: input.getCertificates
+}, _errorFactory)) && (undefined === input.getCertificates || "string" === typeof input.getCertificates || ("object" === typeof input.getCertificates && null !== input.getCertificates || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".getCertificates",
+    expected: "(ExternalURL | string | undefined)",
+    value: input.getCertificates
+}, _errorFactory)) && _ao0(input.getCertificates, _path + ".getCertificates", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".getCertificates",
+    expected: "(ExternalURL | string | undefined)",
+    value: input.getCertificates
+}, _errorFactory))); const _ao9 = (input, _path, _exceptionable = true) => (null !== input.inputCurrencyCodes || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".inputCurrencyCodes",
+    expected: "(Array<ExternalURL | ToJSONValuizableObject<{ outputCurrencyCodes: string[]; kycProviders: string[]; }>> | ExternalURL)",
+    value: input.inputCurrencyCodes
+}, _errorFactory)) && (undefined !== input.inputCurrencyCodes || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".inputCurrencyCodes",
+    expected: "(Array<ExternalURL | ToJSONValuizableObject<{ outputCurrencyCodes: string[]; kycProviders: string[]; }>> | ExternalURL)",
+    value: input.inputCurrencyCodes
+}, _errorFactory)) && (Array.isArray(input.inputCurrencyCodes) && input.inputCurrencyCodes.every((elem, _index12) => ("object" === typeof elem && null !== elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".inputCurrencyCodes[" + _index12 + "]",
+    expected: "(ExternalURL | ToJSONValuizableObject<__type>.o8)",
+    value: elem
+}, _errorFactory)) && _au0(elem, _path + ".inputCurrencyCodes[" + _index12 + "]", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".inputCurrencyCodes[" + _index12 + "]",
+    expected: "(ExternalURL | ToJSONValuizableObject<__type>.o8)",
+    value: elem
+}, _errorFactory)) || "object" === typeof input.inputCurrencyCodes && null !== input.inputCurrencyCodes && _ao0(input.inputCurrencyCodes, _path + ".inputCurrencyCodes", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".inputCurrencyCodes",
+    expected: "(Array<ExternalURL | ToJSONValuizableObject<{ outputCurrencyCodes: string[]; kycProviders: string[]; }>> | ExternalURL)",
+    value: input.inputCurrencyCodes
+}, _errorFactory) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".inputCurrencyCodes",
+    expected: "(Array<ExternalURL | ToJSONValuizableObject<{ outputCurrencyCodes: string[]; kycProviders: string[]; }>> | ExternalURL)",
+    value: input.inputCurrencyCodes
+}, _errorFactory)); const _ao10 = (input, _path, _exceptionable = true) => (null !== input.outputCurrencyCodes || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".outputCurrencyCodes",
+    expected: "(Array<string | ExternalURL> | ExternalURL)",
+    value: input.outputCurrencyCodes
+}, _errorFactory)) && (undefined !== input.outputCurrencyCodes || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".outputCurrencyCodes",
+    expected: "(Array<string | ExternalURL> | ExternalURL)",
+    value: input.outputCurrencyCodes
+}, _errorFactory)) && (Array.isArray(input.outputCurrencyCodes) && input.outputCurrencyCodes.every((elem, _index13) => (null !== elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".outputCurrencyCodes[" + _index13 + "]",
+    expected: "(ExternalURL | string)",
+    value: elem
+}, _errorFactory)) && (undefined !== elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".outputCurrencyCodes[" + _index13 + "]",
+    expected: "(ExternalURL | string)",
+    value: elem
+}, _errorFactory)) && ("string" === typeof elem || ("object" === typeof elem && null !== elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".outputCurrencyCodes[" + _index13 + "]",
+    expected: "(ExternalURL | string)",
+    value: elem
+}, _errorFactory)) && _ao0(elem, _path + ".outputCurrencyCodes[" + _index13 + "]", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".outputCurrencyCodes[" + _index13 + "]",
+    expected: "(ExternalURL | string)",
+    value: elem
+}, _errorFactory))) || "object" === typeof input.outputCurrencyCodes && null !== input.outputCurrencyCodes && _ao0(input.outputCurrencyCodes, _path + ".outputCurrencyCodes", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".outputCurrencyCodes",
+    expected: "(Array<string | ExternalURL> | ExternalURL)",
+    value: input.outputCurrencyCodes
+}, _errorFactory) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".outputCurrencyCodes",
+    expected: "(Array<string | ExternalURL> | ExternalURL)",
+    value: input.outputCurrencyCodes
+}, _errorFactory)) && ((null !== input.kycProviders || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".kycProviders",
+    expected: "(Array<string | ExternalURL> | ExternalURL)",
+    value: input.kycProviders
+}, _errorFactory)) && (undefined !== input.kycProviders || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".kycProviders",
+    expected: "(Array<string | ExternalURL> | ExternalURL)",
+    value: input.kycProviders
+}, _errorFactory)) && (Array.isArray(input.kycProviders) && input.kycProviders.every((elem, _index14) => (null !== elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".kycProviders[" + _index14 + "]",
+    expected: "(ExternalURL | string)",
+    value: elem
+}, _errorFactory)) && (undefined !== elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".kycProviders[" + _index14 + "]",
+    expected: "(ExternalURL | string)",
+    value: elem
+}, _errorFactory)) && ("string" === typeof elem || ("object" === typeof elem && null !== elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".kycProviders[" + _index14 + "]",
+    expected: "(ExternalURL | string)",
+    value: elem
+}, _errorFactory)) && _ao0(elem, _path + ".kycProviders[" + _index14 + "]", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".kycProviders[" + _index14 + "]",
+    expected: "(ExternalURL | string)",
+    value: elem
+}, _errorFactory))) || "object" === typeof input.kycProviders && null !== input.kycProviders && _ao0(input.kycProviders, _path + ".kycProviders", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".kycProviders",
+    expected: "(Array<string | ExternalURL> | ExternalURL)",
+    value: input.kycProviders
+}, _errorFactory) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".kycProviders",
+    expected: "(Array<string | ExternalURL> | ExternalURL)",
+    value: input.kycProviders
+}, _errorFactory))); const _ao11 = (input, _path, _exceptionable = true) => (null !== input.workInProgress || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".workInProgress",
+    expected: "(ExternalURL | true | undefined)",
+    value: input.workInProgress
+}, _errorFactory)) && (undefined === input.workInProgress || true === input.workInProgress || ("object" === typeof input.workInProgress && null !== input.workInProgress || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".workInProgress",
+    expected: "(ExternalURL | true | undefined)",
+    value: input.workInProgress
+}, _errorFactory)) && _ao0(input.workInProgress, _path + ".workInProgress", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".workInProgress",
+    expected: "(ExternalURL | true | undefined)",
+    value: input.workInProgress
+}, _errorFactory)); const _ao12 = (input, _path, _exceptionable = true) => (null !== input.workInProgress || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".workInProgress",
+    expected: "(ExternalURL | true | undefined)",
+    value: input.workInProgress
+}, _errorFactory)) && (undefined === input.workInProgress || true === input.workInProgress || ("object" === typeof input.workInProgress && null !== input.workInProgress || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".workInProgress",
+    expected: "(ExternalURL | true | undefined)",
+    value: input.workInProgress
+}, _errorFactory)) && _ao0(input.workInProgress, _path + ".workInProgress", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".workInProgress",
+    expected: "(ExternalURL | true | undefined)",
+    value: input.workInProgress
+}, _errorFactory)); const _ao13 = (input, _path, _exceptionable = true) => (null !== input.workInProgress || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".workInProgress",
+    expected: "(ExternalURL | true | undefined)",
+    value: input.workInProgress
+}, _errorFactory)) && (undefined === input.workInProgress || true === input.workInProgress || ("object" === typeof input.workInProgress && null !== input.workInProgress || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".workInProgress",
+    expected: "(ExternalURL | true | undefined)",
+    value: input.workInProgress
+}, _errorFactory)) && _ao0(input.workInProgress, _path + ".workInProgress", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".workInProgress",
+    expected: "(ExternalURL | true | undefined)",
+    value: input.workInProgress
+}, _errorFactory)); const _au0 = (input, _path, _exceptionable = true) => (() => {
+    if (undefined !== input.external)
+        return _ao0(input, _path, true && _exceptionable);
+    else if (undefined !== input.outputCurrencyCodes)
+        return _ao10(input, _path, true && _exceptionable);
+    else
+        return __typia_transform__assertGuard._assertGuard(_exceptionable, {
+            method: "createAssert",
+            path: _path,
+            expected: "(ExternalURL | ToJSONValuizableObject<__type>.o8)",
+            value: input
+        }, _errorFactory);
+})(); const _au1 = (input, _path, _exceptionable = true) => (() => {
+    if (undefined !== input.external)
+        return _ao0(input, _path, true && _exceptionable);
+    else
+        return _ao2(input, _path, true && _exceptionable);
+})(); const _au2 = (input, _path, _exceptionable = true) => (() => {
+    if (undefined !== input.external)
+        return _ao0(input, _path, true && _exceptionable);
+    else
+        return _ao3(input, _path, true && _exceptionable);
+})(); const _au3 = (input, _path, _exceptionable = true) => (() => {
+    if (undefined !== input.external)
+        return _ao0(input, _path, true && _exceptionable);
+    else
+        return _ao6(input, _path, true && _exceptionable);
+})(); const _au4 = (input, _path, _exceptionable = true) => (() => {
+    if (undefined !== input.external)
+        return _ao0(input, _path, true && _exceptionable);
+    else if (undefined !== input.inputCurrencyCodes)
+        return _ao9(input, _path, true && _exceptionable);
+    else
+        return __typia_transform__assertGuard._assertGuard(_exceptionable, {
+            method: "createAssert",
+            path: _path,
+            expected: "(ExternalURL | ToJSONValuizableObject<__type>.o7)",
+            value: input
+        }, _errorFactory);
+})(); const _au5 = (input, _path, _exceptionable = true) => (() => {
+    if (undefined !== input.external)
+        return _ao0(input, _path, true && _exceptionable);
+    else
+        return _ao11(input, _path, true && _exceptionable);
+})(); const _au6 = (input, _path, _exceptionable = true) => (() => {
+    if (undefined !== input.external)
+        return _ao0(input, _path, true && _exceptionable);
+    else
+        return _ao12(input, _path, true && _exceptionable);
+})(); const _au7 = (input, _path, _exceptionable = true) => (() => {
+    if (undefined !== input.external)
+        return _ao0(input, _path, true && _exceptionable);
+    else
+        return _ao13(input, _path, true && _exceptionable);
+})(); const _au8 = (input, _path, _exceptionable = true) => (() => {
+    if (undefined !== input.external)
+        return _ao0(input, _path, true && _exceptionable);
+    else if (undefined !== input.operations)
+        return _ao4(input, _path, true && _exceptionable);
+    else
+        return __typia_transform__assertGuard._assertGuard(_exceptionable, {
+            method: "createAssert",
+            path: _path,
+            expected: "(ExternalURL | ToJSONValuizableObject<__type>.o2)",
+            value: input
+        }, _errorFactory);
+})(); const _au9 = (input, _path, _exceptionable = true) => (() => {
+    if (undefined !== input.external)
+        return _ao0(input, _path, true && _exceptionable);
+    else
+        return _ao5(input, _path, true && _exceptionable);
+})(); const _au10 = (input, _path, _exceptionable = true) => (() => {
+    if (undefined !== input.external)
+        return _ao0(input, _path, true && _exceptionable);
+    else if (undefined !== input.operations)
+        return _ao7(input, _path, true && _exceptionable);
+    else
+        return __typia_transform__assertGuard._assertGuard(_exceptionable, {
+            method: "createAssert",
+            path: _path,
+            expected: "(ExternalURL | ToJSONValuizableObject<__type>.o5)",
+            value: input
+        }, _errorFactory);
+})(); const _au11 = (input, _path, _exceptionable = true) => (() => {
+    if (undefined !== input.external)
+        return _ao0(input, _path, true && _exceptionable);
+    else
+        return _ao8(input, _path, true && _exceptionable);
+})(); const _au12 = (input, _path, _exceptionable = true) => (() => {
+    if (undefined !== input.external)
+        return _ao0(input, _path, true && _exceptionable);
+    else if (undefined !== input.version)
+        return _ao1(input, _path, true && _exceptionable);
+    else
+        return __typia_transform__assertGuard._assertGuard(_exceptionable, {
+            method: "createAssert",
+            path: _path,
+            expected: "(ExternalURL | ToJSONValuizableObject<ServiceMetadata>)",
+            value: input
+        }, _errorFactory);
+})(); const __is = input => "object" === typeof input && null !== input && _iu12(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: "(ExternalURL | ToJSONValuizableObject<ServiceMetadata>)",
+            value: input
+        }, _errorFactory)) && _au12(input, _path + "", true) || __typia_transform__assertGuard._assertGuard(true, {
+            method: "createAssert",
+            path: _path + "",
+            expected: "(ExternalURL | ToJSONValuizableObject<ServiceMetadata>)",
+            value: input
+        }, _errorFactory))(input, "$input", true);
+    }
+    return input;
+}; })();
+class Metadata {
+    #cache;
+    #trustedCAs;
+    #client;
+    #logger;
+    #url;
+    #resolver;
+    #stats;
+    seenURLs;
+    static instanceTypeID = 'Metadata:c85b3d67-9548-4042-9862-f6e6677690ac';
+    static isInstance(value) {
+        if (typeof value !== 'object' || value === null) {
+            return (false);
+        }
+        if (!('instanceID' in value)) {
+            return (false);
+        }
+        return (value.instanceID === Metadata.instanceTypeID);
+    }
+    static formatMetadata(metadata) {
+        return (Buffer.from(JSON.stringify(metadata)).toString('base64'));
+    }
+    /**
+     * Assert that the supplied value is a valid Metadata Root Object
+     */
+    static assertMetadata(value) {
+        assertServiceMetadata(value);
+    }
+    constructor(url, config) {
+        /*
+         * Define an "instanceTypeID" as an unenumerable property to
+         * ensure that we can identify this object as an instance of
+         * Metadata, but we do not need to serialize it.
+         */
+        Object.defineProperty(this, 'instanceTypeID', {
+            value: Metadata.instanceTypeID,
+            enumerable: false
+        });
+        this.#url = new URL(url);
+        this.#cache = {
+            // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+            instance: config.cache?.instance ?? new Map(),
+            positiveTTL: config.cache?.positiveTTL ?? 60 * 1000,
+            negativeTTL: config.cache?.negativeTTL ?? 5 * 1000
+        };
+        this.#trustedCAs = config.trustedCAs;
+        this.#client = config.client;
+        this.#logger = config.logger;
+        this.#resolver = config.resolver;
+        this.#stats = this.#resolver._mutableStats(statsAccessToken);
+        if (config.parent !== undefined) {
+            this.seenURLs = config.parent.seenURLs;
+        }
+        else {
+            this.seenURLs = new Set();
+        }
+    }
+    async parseMetadata(metadata) {
+        /*
+         * JSON.parse() will always return a JSONSerializable,
+         * and not `unknown`, so we can safely cast it.
+         */
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+        const retval = await this.resolveValue(JSON.parse(metadata));
+        return (retval);
+    }
+    async readKeetaNetURL(url) {
+        const accountString = url.hostname;
+        const path = url.pathname;
+        this.#stats.keetanet.reads++;
+        if (path !== '/metadata') {
+            throw (new Error(`Unsupported path: ${path}`));
+        }
+        let account;
+        try {
+            account = KeetaNetClient.lib.Account.fromPublicKeyString(accountString);
+        }
+        catch {
+            return ('');
+        }
+        const accountInfo = await this.#client.getAccountInfo(account);
+        const metadata = Buffer.from(accountInfo.info.metadata, 'base64').toString('utf-8');
+        if (metadata === '') {
+            return ('');
+        }
+        this.#logger?.debug(`Resolver:${this.#resolver.id}`, 'Account info for', accountString, '=', accountInfo.info);
+        const retval = await this.parseMetadata(metadata);
+        return (retval);
+    }
+    async readHTTPSURL(url) {
+        this.#stats.https.reads++;
+        const results = await fetch(url.toString(), {
+            method: 'GET',
+            headers: {
+                'Accept': 'application/json'
+            }
+        });
+        if (!results.ok) {
+            throw (new Error(`Error HTTP status ${results.status} ${results.statusText} for ${url.toString()}`));
+        }
+        if (results.status === 204) {
+            /*
+             * 204 No Content is a valid response, so we return an empty
+             * object.
+             */
+            return ({});
+        }
+        if (results.status !== 200) {
+            throw (new Error(`Unexpected HTTP status ${results.status} for ${url.toString()}`));
+        }
+        const metadata = JSON.stringify(await results.json());
+        this.#logger?.debug(`Resolver:${this.#resolver.id}`, 'Read URL', url.toString(), ':', metadata);
+        const retval = await this.parseMetadata(metadata);
+        return (retval);
+    }
+    async readURL(url) {
+        this.#stats.reads++;
+        const cacheKey = url.toString();
+        /*
+         * To ensure any circular references are handled correctly, we
+         * keep track of a chain of accessed URLs.  If we see the same
+         * URL twice, then we have a circular reference.
+         */
+        if (this.seenURLs.has(cacheKey)) {
+            return ('');
+        }
+        this.seenURLs.add(cacheKey);
+        /*
+         * Verify that the cache entry is still valid.  If it is not,
+         * then remove it from the cache.
+         */
+        let cacheVal = this.#cache.instance.get(cacheKey);
+        if (this.#cache.instance.has(cacheKey) && cacheVal !== undefined) {
+            if (cacheVal.expires < new Date()) {
+                this.#cache.instance.delete(cacheKey);
+                cacheVal = undefined;
+            }
+        }
+        if (cacheVal !== undefined) {
+            this.#stats.cache.hit++;
+            if (cacheVal.pass) {
+                return (cacheVal.value);
+            }
+            else {
+                throw (cacheVal.error);
+            }
+        }
+        this.#stats.cache.miss++;
+        let retval;
+        try {
+            const protocol = url.protocol;
+            if (protocol === 'keetanet:') {
+                retval = await this.readKeetaNetURL(url);
+            }
+            else if (protocol === 'https:') {
+                retval = await this.readHTTPSURL(url);
+            }
+            else {
+                this.#stats.unsupported.reads++;
+                throw (new Error(`Unsupported protocol: ${protocol}`));
+            }
+        }
+        catch (readError) {
+            this.#cache.instance.set(cacheKey, {
+                pass: false,
+                error: readError,
+                expires: new Date(Date.now() + this.#cache.negativeTTL)
+            });
+            this.#logger?.debug(`Resolver:${this.#resolver.id}`, 'Read URL', url.toString(), 'failed:', readError);
+            throw (readError);
+        }
+        this.#logger?.debug(`Resolver:${this.#resolver.id}`, 'Read URL', url.toString(), ':', retval);
+        this.#cache.instance.set(cacheKey, {
+            pass: true,
+            value: retval,
+            expires: new Date(Date.now() + this.#cache.positiveTTL)
+        });
+        return (retval);
+    }
+    async resolveValue(value) {
+        if (value === undefined) {
+            return (value);
+        }
+        /*
+         * If the value passed in is a reference to an external URL, then
+         * we need to read that URL (and continue to resolve it).
+         */
+        if (isExternalURL(value)) {
+            const url = new URL(value.url);
+            const retval = await this.readURL(url);
+            return (await this.resolveValue(retval));
+        }
+        return (value);
+    }
+    assertValuizableKind(input, expect) {
+        switch (expect) {
+            case 'any':
+                return (input);
+            case 'object':
+                if (typeof input !== 'object') {
+                    throw (new Error(`expected an object, got ${typeof input}`));
+                }
+                if (input === null) {
+                    throw (new Error('expected an object, got null'));
+                }
+                if (Array.isArray(input)) {
+                    throw (new Error('expected an object, got an array'));
+                }
+                return (input);
+            case 'array':
+                if (!Array.isArray(input)) {
+                    throw (new Error(`expected an array, got ${typeof input}`));
+                }
+                return (input);
+            case 'primitive':
+                if ((typeof input === 'object' && input !== null) || input === undefined) {
+                    throw (new Error(`expected a primitive, got ${typeof input}`));
+                }
+                return (input);
+            case 'string':
+            case 'number':
+            case 'boolean':
+                if (typeof input !== expect) {
+                    throw (new Error(`expected a ${expect}, got ${typeof input}`));
+                }
+                return (input);
+            default:
+                assertNever(expect);
+        }
+    }
+    async valuize(value) {
+        if (typeof value === 'object' && value !== null) {
+            let newValue;
+            if (Array.isArray(value)) {
+                newValue = [];
+            }
+            else {
+                newValue = {};
+            }
+            for (const key in value) {
+                /*
+                 * Since `key` is the index of the array or
+                 * object, it is safe to use it to index
+                 * into the array or object.
+                 */
+                // @ts-ignore
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+                const keyValue = value[key];
+                if (isExternalURL(keyValue)) {
+                    const newMetadataObject = new Metadata(keyValue.url, {
+                        trustedCAs: this.#trustedCAs,
+                        client: this.#client,
+                        logger: this.#logger,
+                        resolver: this.#resolver,
+                        cache: this.#cache,
+                        parent: this
+                    });
+                    const newValuizableObject = newMetadataObject.value.bind(newMetadataObject);
+                    if (Array.isArray(newValue)) {
+                        throw (new Error('internal error: newValue is an array, but it should be an object since it is an external field, which can  only be an object'));
+                    }
+                    newValue[key] = newValuizableObject;
+                }
+                else {
+                    /*
+                     * This is safe because `assertValuizableKind` will
+                     * ensure the correct output type
+                     */
+                    // @ts-ignore
+                    const newValueEntry = async (expect = 'any') => {
+                        const retval = this.assertValuizableKind(await this.valuize(keyValue), expect);
+                        return (retval);
+                    };
+                    /*
+                     * TypeScript doesn't track that `key`
+                     * is a valid index regardless of the
+                     * type of `newValue` is an array or an
+                     * object, so we need to use `@ts-ignore`
+                     */
+                    // @ts-ignore
+                    newValue[key] = newValueEntry;
+                }
+            }
+            return (newValue);
+        }
+        else {
+            return (value);
+        }
+    }
+    async value(expect = 'any') {
+        const value = await this.readURL(this.#url);
+        const retval = this.assertValuizableKind(await this.valuize(value), expect);
+        return (retval);
+    }
+}
+function assertValidCountryCodes(input) {
+    if (typeof input !== 'object' || input === null) {
+        throw (new Error(`Expected an object, got ${typeof input}`));
+    }
+    if (!('countryCodes' in input)) {
+        throw (new Error('Expected "countryCodes" to be present, but it was not found'));
+    }
+    if (typeof input.countryCodes !== 'function' && !Array.isArray(input.countryCodes)) {
+        throw (new Error(`Expected "countryCodes" to be an array | function, got ${typeof input.countryCodes}`));
+    }
+    if (Array.isArray(input.countryCodes)) {
+        for (const countryCode of input.countryCodes) {
+            if (typeof countryCode !== 'string') {
+                throw (new Error(`Expected "countryCodes" to be an array of strings, got ${typeof countryCode}`));
+            }
+        }
+    }
+}
+function assertValidOptionalCountryCodes(input) {
+    if (typeof input !== 'object' || input === null) {
+        throw (new Error(`Expected an object, got ${typeof input}`));
+    }
+    if (!('countryCodes' in input)) {
+        return;
+    }
+    assertValidCountryCodes(input);
+}
+function assertValidCurrencyCodes(input) {
+    if (typeof input !== 'object' || input === null) {
+        throw (new Error(`Expected an object, got ${typeof input}`));
+    }
+    if (!('currencyCodes' in input)) {
+        throw (new Error('Expected "currencyCodes" to be present, but it was not found'));
+    }
+    if (typeof input.currencyCodes !== 'function' && !Array.isArray(input.currencyCodes)) {
+        throw (new Error(`Expected "currencyCodes" to be an array | function, got ${typeof input.currencyCodes}`));
+    }
+    if (Array.isArray(input.currencyCodes)) {
+        for (const currencyCode of input.currencyCodes) {
+            if (typeof currencyCode !== 'string') {
+                throw (new Error(`Expected "currencyCodes" to be an array of strings, got ${typeof currencyCode}`));
+            }
+        }
+    }
+}
+function assertValidOperationsBanking(input) {
+    if (typeof input !== 'object' || input === null) {
+        throw (new Error(`Expected an object, got ${typeof input}`));
+    }
+    if (!('operations' in input)) {
+        throw (new Error('Expected "operations" key in KYC service, but it was not found'));
+    }
+    if ((typeof input.operations !== 'object' || input.operations === null) && typeof input.operations !== 'function') {
+        throw (new Error(`Expected "operations" to be an object | function, got ${typeof input.operations}`));
+    }
+    if (typeof input.operations !== 'function') {
+        for (const [operation, operationValue] of Object.entries(input.operations)) {
+            if (typeof operation !== 'string') {
+                throw (new Error(`Expected "operations" to be an object with string keys, got ${typeof operation}`));
+            }
+            if (typeof operationValue !== 'string') {
+                throw (new Error(`Expected "operations.${operation}" to be a string, got ${typeof operationValue}`));
+            }
+        }
+    }
+}
+function assertValidOperationsKYC(input) {
+    assertValidOperationsBanking(input);
+}
+function assertValidOptionalKYCProviders(input) {
+    if (typeof input !== 'object' || input === null) {
+        throw (new Error(`Expected an object, got ${typeof input}`));
+    }
+    if ('kycProviders' in input) {
+        if (typeof input.kycProviders !== 'function' && !Array.isArray(input.kycProviders)) {
+            throw (new Error(`Expected "kycProviders" to be an array | function, got ${typeof input.kycProviders}`));
+        }
+        if (Array.isArray(input.kycProviders)) {
+            for (const kycProvider of input.kycProviders) {
+                if (typeof kycProvider !== 'string') {
+                    throw (new Error(`Expected "kycProviders" to be an array of strings, got ${typeof kycProvider}`));
+                }
+            }
+        }
+    }
+}
+function assertValidCA(input) {
+    if (typeof input !== 'object' || input === null) {
+        throw (new Error(`Expected an object, got ${typeof input}`));
+    }
+    if (!('ca' in input)) {
+        throw (new Error('Expected "ca" key in KYC service, but it was not found'));
+    }
+    if (typeof input.ca !== 'string' && typeof input.ca !== 'function') {
+        throw (new Error(`Expected "ca" to be a string | function, got ${typeof input.ca}`));
+    }
+}
+const assertResolverLookupBankingResult = function (input) {
+    assertValidOperationsBanking(input);
+    assertValidCountryCodes(input);
+    assertValidCurrencyCodes(input);
+    assertValidOptionalKYCProviders(input);
+    return (input);
+};
+const assertResolverLookupKYCResult = function (input) {
+    assertValidOperationsKYC(input);
+    assertValidOptionalCountryCodes(input);
+    assertValidCA(input);
+    return (input);
+};
+class Resolver {
+    #root;
+    #trustedCAs;
+    #client;
+    #logger;
+    #stats;
+    #metadataCache;
+    id;
+    static Metadata = Metadata;
+    constructor(config) {
+        this.#root = config.root;
+        this.#trustedCAs = config.trustedCAs;
+        this.#logger = config.logger;
+        this.#metadataCache = {
+            ...config.cache,
+            instance: new Map()
+        };
+        this.id = config.id ?? crypto.randomUUID();
+        this.#logger?.debug(`Resolver:${this.id}`, 'Creating resolver with root account', this.#root.publicKeyString.get());
+        if (KeetaNetClient.Client.isInstance(config.client)) {
+            this.#client = config.client;
+        }
+        else {
+            this.#client = config.client.client;
+        }
+        this.#stats = {
+            keetanet: {
+                reads: 0
+            },
+            https: {
+                reads: 0
+            },
+            unsupported: {
+                reads: 0
+            },
+            reads: 0,
+            cache: {
+                hit: 0,
+                miss: 0
+            }
+        };
+    }
+    /** @internal */
+    _mutableStats(accessToken) {
+        if (accessToken !== statsAccessToken) {
+            throw (new Error('Invalid access token'));
+        }
+        return (this.#stats);
+    }
+    get stats() {
+        return (structuredClone(this.#stats));
+    }
+    async lookupBankingServices(bankingServices, criteria) {
+        if (bankingServices === undefined) {
+            return (undefined);
+        }
+        const retval = {};
+        for (const checkBankingServiceID in bankingServices) {
+            try {
+                const checkBankingService = await bankingServices[checkBankingServiceID]?.('object');
+                if (checkBankingService === undefined) {
+                    continue;
+                }
+                if (!('operations' in checkBankingService)) {
+                    continue;
+                }
+                if (criteria.currencyCodes !== undefined) {
+                    const currencyCodes = await checkBankingService.currencyCodes?.('array') ?? [];
+                    const checkBankingServiceCurrencyCodes = await Promise.all(currencyCodes.map(async function (item) {
+                        return (await item?.('primitive'));
+                    }));
+                    let acceptable = true;
+                    for (const checkCurrencyCode of criteria.currencyCodes) {
+                        const checkCurrencyCodeCanonical = convertToCurrencySearchCanonical(checkCurrencyCode);
+                        if (!checkBankingServiceCurrencyCodes.includes(checkCurrencyCodeCanonical)) {
+                            acceptable = false;
+                            break;
+                        }
+                    }
+                    if (!acceptable) {
+                        continue;
+                    }
+                }
+                if (criteria.countryCodes !== undefined) {
+                    const countryCodes = await checkBankingService.countryCodes?.('array') ?? [];
+                    const checkBankingServiceCountryCodes = await Promise.all(countryCodes.map(async function (item) {
+                        return (await item?.('primitive'));
+                    }));
+                    this.#logger?.debug(`Resolver:${this.id}`, 'Checking country codes:', criteria.countryCodes, 'against', checkBankingServiceCountryCodes, 'for', checkBankingServiceID);
+                    let acceptable = true;
+                    for (const checkCountryCode of criteria.countryCodes) {
+                        const checkCountryCodeCanonical = convertToCountrySearchCanonical(checkCountryCode);
+                        if (!checkBankingServiceCountryCodes.includes(checkCountryCodeCanonical)) {
+                            acceptable = false;
+                            break;
+                        }
+                    }
+                    if (!acceptable) {
+                        continue;
+                    }
+                }
+                retval[checkBankingServiceID] = assertResolverLookupBankingResult(checkBankingService);
+            }
+            catch (checkBankingServiceError) {
+                this.#logger?.debug(`Resolver:${this.id}`, 'Error checking banking service', checkBankingServiceID, ':', checkBankingServiceError, ' -- ignoring');
+            }
+        }
+        if (Object.keys(retval).length === 0) {
+            /*
+             * If we didn't find any banking services, then we return
+             * undefined to indicate that no services were found.
+             */
+            return (undefined);
+        }
+        return (retval);
+    }
+    async lookupKYCServices(kycServices, criteria) {
+        if (kycServices === undefined) {
+            return (undefined);
+        }
+        const retval = {};
+        for (const checkKYCServiceID in kycServices) {
+            try {
+                const checkKYCService = await kycServices[checkKYCServiceID]?.('object');
+                if (checkKYCService === undefined) {
+                    continue;
+                }
+                if (!('operations' in checkKYCService)) {
+                    continue;
+                }
+                if (criteria.countryCodes !== undefined) {
+                    let acceptable = true;
+                    /*
+                     * If the KYC service does not have a countryCodes
+                     * property, then it can validate accounts in any
+                     * country, so we skip this check.
+                     */
+                    if ('countryCodes' in checkKYCService) {
+                        const countryCodes = await checkKYCService.countryCodes?.('array') ?? [];
+                        const checkKYCServiceCountryCodes = await Promise.all(countryCodes.map(async function (item) {
+                            return (await item?.('string'));
+                        }));
+                        this.#logger?.debug(`Resolver:${this.id}`, 'Checking country codes:', criteria.countryCodes, 'against', checkKYCServiceCountryCodes, 'for', checkKYCServiceID);
+                        for (const checkCountryCode of criteria.countryCodes) {
+                            const checkCountryCodeCanonical = convertToCountrySearchCanonical(checkCountryCode);
+                            if (!checkKYCServiceCountryCodes.includes(checkCountryCodeCanonical)) {
+                                acceptable = false;
+                                break;
+                            }
+                        }
+                    }
+                    if (!acceptable) {
+                        continue;
+                    }
+                }
+                retval[checkKYCServiceID] = assertResolverLookupKYCResult(checkKYCService);
+            }
+            catch (checkKYCServiceError) {
+                this.#logger?.debug(`Resolver:${this.id}`, 'Error checking KYC service', checkKYCServiceID, ':', checkKYCServiceError, ' -- ignoring');
+            }
+        }
+        if (Object.keys(retval).length === 0) {
+            /*
+             * If we didn't find any banking services, then we return
+             * undefined to indicate that no services were found.
+             */
+            return (undefined);
+        }
+        return (retval);
+    }
+    async lookup(service, criteria) {
+        const rootURL = new URL(`keetanet://${this.#root.publicKeyString.get()}/metadata`);
+        const metadata = new Metadata(rootURL, {
+            trustedCAs: this.#trustedCAs,
+            client: this.#client,
+            logger: this.#logger,
+            resolver: this,
+            cache: this.#metadataCache
+        });
+        const rootMetadata = await metadata.value('object');
+        this.#logger?.debug(`Resolver:${this.id}`, 'Root Metadata:', rootMetadata);
+        if (!('version' in rootMetadata)) {
+            throw (new Error('Root metadata is missing "version" property'));
+        }
+        const rootMetadataVersion = await rootMetadata.version?.('primitive');
+        if (rootMetadataVersion !== 1) {
+            throw (new Error(`Unsupported metadata version: ${rootMetadataVersion}`));
+        }
+        /*
+         * Get the services object
+         */
+        const definedServicesProperty = rootMetadata.services;
+        if (definedServicesProperty === undefined) {
+            throw (new Error('Root metadata is missing "services" property'));
+        }
+        const definedServices = await definedServicesProperty('object');
+        // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+        const args = { service, criteria };
+        this.#logger?.debug(`Resolver:${this.id}`, 'Looking up', args.service, 'with criteria:', args.criteria, 'in', definedServices);
+        switch (args.service) {
+            case 'banking': {
+                const currentCriteria = args.criteria;
+                const bankingServices = await definedServices.banking?.('object');
+                this.#logger?.debug(`Resolver:${this.id}`, 'Banking Services:', bankingServices);
+                return (await this.lookupBankingServices(bankingServices, currentCriteria));
+            }
+            case 'kyc': {
+                const currentCriteria = args.criteria;
+                const kycServices = await definedServices.kyc?.('object');
+                this.#logger?.debug(`Resolver:${this.id}`, 'KYC Services:', kycServices);
+                return (await this.lookupKYCServices(kycServices, currentCriteria));
+            }
+            case 'fx':
+            case 'inbound':
+            case 'outbound':
+            case 'cards':
+                throw (new Error('not implemented'));
+            default:
+                assertNever(args);
+        }
+    }
+    clearCache() {
+        this.#metadataCache.instance.clear();
+        this.#stats.cache.hit = 0;
+        this.#stats.cache.miss = 0;
+        this.#stats.https.reads = 0;
+        this.#stats.keetanet.reads = 0;
+        this.#stats.unsupported.reads = 0;
+        this.#stats.reads = 0;
+    }
+}
+export default Resolver;
+//# sourceMappingURL=resolver.js.map