@keetanetwork/anchor 0.0.13 → 0.0.15

package/lib/utils/asn1.js

@@ -1,8 +1,1421 @@
+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 { Buffer } from './buffer.js';
+import { assert, createAssert, createIs } from 'typia';
 const ASN1 = KeetaNetLib.Utils.ASN1;
 const ASN1toJS = ASN1.ASN1toJS;
 const JStoASN1 = ASN1.JStoASN1;
 const BufferStorageASN1 = ASN1.BufferStorageASN1;
 const ValidateASN1 = ASN1.ValidateASN1;
+const ASN1CheckUtilities = ASN1.ASN1CheckUtilities;
+const { isASN1ContextTag, isASN1Struct, isASN1String, isASN1Date, isASN1BitString, isASN1Set } = ASN1CheckUtilities;
+const assertStructFieldSchemaMap = (() => { const _ip0 = input => {
+    const array = input;
+    const top = input[0];
+    if (0 === input.length)
+        return true;
+    const arrayPredicators = [
+        [
+            top => null !== top && undefined !== top && ("function" === typeof top || "bigint" === typeof top || (Array.isArray(top) && (_it0(top) || false) || "object" === typeof top && null !== top && _iu0(top))),
+            entire => entire.every(elem => null !== elem && undefined !== elem && ("function" === typeof elem || "bigint" === typeof elem || (Array.isArray(elem) && (_it0(elem) || false) || "object" === typeof elem && null !== elem && _iu0(elem))))
+        ],
+        [
+            top => null !== top && undefined !== top && ("function" === typeof top || "bigint" === typeof top || (Array.isArray(top) && (_it0(top) || false) || "object" === typeof top && null !== top && _iu0(top))),
+            entire => entire.every(elem => null !== elem && undefined !== elem && ("function" === typeof elem || "bigint" === typeof elem || (Array.isArray(elem) && (_it0(elem) || false) || "object" === typeof elem && null !== elem && _iu0(elem))))
+        ]
+    ];
+    const passed = arrayPredicators.filter(pred => pred[0](top));
+    if (1 === passed.length)
+        return passed[0][1](array);
+    else if (1 < passed.length)
+        for (const pred of passed)
+            if (array.every(value => true === pred[0](value)))
+                return pred[1](array);
+    return false;
+}; const _ap1 = (input, _path, _exceptionable = true) => {
+    const array = input;
+    const top = input[0];
+    if (0 === input.length)
+        return true;
+    const arrayPredicators = [
+        [
+            top => null !== top && undefined !== top && ("function" === typeof top || "bigint" === typeof top || (Array.isArray(top) && (_at0(top, _path, false && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                method: "createAssert",
+                path: _path,
+                expected: "readonly [Schema, ...Schema[]]",
+                value: top
+            }, _errorFactory)) || "object" === typeof top && null !== top && _au0(top, _path, false && _exceptionable))),
+            entire => entire.every((elem, _index9) => (null !== elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                method: "createAssert",
+                path: _path + "[" + _index9 + "]",
+                expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
+                value: elem
+            }, _errorFactory)) && (undefined !== elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                method: "createAssert",
+                path: _path + "[" + _index9 + "]",
+                expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
+                value: elem
+            }, _errorFactory)) && ("function" === typeof elem || "bigint" === typeof elem || (Array.isArray(elem) && (_at0(elem, _path + "[" + _index9 + "]", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                method: "createAssert",
+                path: _path + "[" + _index9 + "]",
+                expected: "readonly [Schema, ...Schema[]]",
+                value: elem
+            }, _errorFactory)) || "object" === typeof elem && null !== elem && _au0(elem, _path + "[" + _index9 + "]", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                method: "createAssert",
+                path: _path + "[" + _index9 + "]",
+                expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
+                value: elem
+            }, _errorFactory)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                method: "createAssert",
+                path: _path + "[" + _index9 + "]",
+                expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
+                value: elem
+            }, _errorFactory)))
+        ],
+        [
+            top => null !== top && undefined !== top && ("function" === typeof top || "bigint" === typeof top || (Array.isArray(top) && (_at0(top, _path, false && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                method: "createAssert",
+                path: _path,
+                expected: "readonly [Schema, ...Schema[]]",
+                value: top
+            }, _errorFactory)) || "object" === typeof top && null !== top && _au0(top, _path, false && _exceptionable))),
+            entire => entire.every((elem, _index10) => (null !== elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                method: "createAssert",
+                path: _path + "[" + _index10 + "]",
+                expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
+                value: elem
+            }, _errorFactory)) && (undefined !== elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                method: "createAssert",
+                path: _path + "[" + _index10 + "]",
+                expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
+                value: elem
+            }, _errorFactory)) && ("function" === typeof elem || "bigint" === typeof elem || (Array.isArray(elem) && (_at0(elem, _path + "[" + _index10 + "]", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                method: "createAssert",
+                path: _path + "[" + _index10 + "]",
+                expected: "readonly [Schema, ...Schema[]]",
+                value: elem
+            }, _errorFactory)) || "object" === typeof elem && null !== elem && _au0(elem, _path + "[" + _index10 + "]", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                method: "createAssert",
+                path: _path + "[" + _index10 + "]",
+                expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
+                value: elem
+            }, _errorFactory)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                method: "createAssert",
+                path: _path + "[" + _index10 + "]",
+                expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
+                value: elem
+            }, _errorFactory)))
+        ]
+    ];
+    const passed = arrayPredicators.filter(pred => pred[0](top));
+    if (1 === passed.length)
+        return passed[0][1](array);
+    else if (1 < passed.length)
+        for (const pred of passed)
+            if (array.every(value => true === pred[0](value)))
+                return pred[1](array);
+    return __typia_transform__assertGuard._assertGuard(_exceptionable, {
+        method: "createAssert",
+        path: _path,
+        expected: "(Array<ValidateASN1.Schema> | ReadonlyArray<ValidateASN1.Schema>)",
+        value: input
+    }, _errorFactory);
+}; const _io0 = input => Object.keys(input).every(key => {
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return null !== value && undefined !== value && ("function" === typeof value || "bigint" === typeof value || (Array.isArray(value) && (_it0(value) || false) || "object" === typeof value && null !== value && _iu1(value)));
+}); const _io1 = input => Array.isArray(input.choice) && (_ip0(input.choice) || false); const _io2 = input => null !== input.sequenceOf && undefined !== input.sequenceOf && ("function" === typeof input.sequenceOf || "bigint" === typeof input.sequenceOf || (Array.isArray(input.sequenceOf) && (_it0(input.sequenceOf) || false) || "object" === typeof input.sequenceOf && null !== input.sequenceOf && _iu0(input.sequenceOf))); const _io3 = input => null !== input.optional && undefined !== input.optional && ("function" === typeof input.optional || "bigint" === typeof input.optional || (Array.isArray(input.optional) && (_it0(input.optional) || false) || "object" === typeof input.optional && null !== input.optional && _iu0(input.optional))); const _io4 = input => "context" === input.type && ("implicit" === input.kind || "explicit" === input.kind) && (null !== input.contains && undefined !== input.contains && ("function" === typeof input.contains || "bigint" === typeof input.contains || (Array.isArray(input.contains) && (_it0(input.contains) || false) || "object" === typeof input.contains && null !== input.contains && _iu0(input.contains)))) && "number" === typeof input.value; const _io5 = input => "oid" === input.type && "string" === typeof input.oid; const _io6 = input => "string" === input.type && "printable" === input.kind; const _io7 = input => "string" === input.type && "ia5" === input.kind; const _io8 = input => "string" === input.type && "utf8" === input.kind; const _io9 = input => "date" === input.type && "utc" === input.kind; const _io10 = input => "date" === input.type && "general" === input.kind; const _io11 = input => "struct" === input.type && (Array.isArray(input.fieldNames) && input.fieldNames.every(elem => "string" === typeof elem)) && ("object" === typeof input.contains && null !== input.contains && false === Array.isArray(input.contains) && _io12(input.contains)); const _io12 = input => Object.keys(input).every(key => {
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return null !== value && undefined !== value && ("function" === typeof value || "bigint" === typeof value || (Array.isArray(value) && (_it0(value) || false) || "object" === typeof value && null !== value && _iu0(value)));
+}); const _io13 = input => null !== input.optional && undefined !== input.optional && ("function" === typeof input.optional || "bigint" === typeof input.optional || (Array.isArray(input.optional) && (_it0(input.optional) || false) || "object" === typeof input.optional && null !== input.optional && _iu0(input.optional))); const _iu0 = input => (() => {
+    if (undefined !== input.choice)
+        return _io1(input);
+    else if (undefined !== input.sequenceOf)
+        return _io2(input);
+    else if (undefined !== input.optional)
+        return _io3(input);
+    else if ("context" === input.type)
+        return _io4(input);
+    else if ("oid" === input.type)
+        return _io5(input);
+    else if ("general" === input.kind)
+        return _io10(input);
+    else if ("utc" === input.kind)
+        return _io9(input);
+    else if ("utf8" === input.kind)
+        return _io8(input);
+    else if ("ia5" === input.kind)
+        return _io7(input);
+    else if ("printable" === input.kind)
+        return _io6(input);
+    else if ("struct" === input.type)
+        return _io11(input);
+    else
+        return false;
+})(); const _iu1 = input => (() => {
+    if (undefined !== input.choice)
+        return _io1(input);
+    else if (undefined !== input.sequenceOf)
+        return _io2(input);
+    else if ("context" === input.type)
+        return _io4(input);
+    else if ("oid" === input.type)
+        return _io5(input);
+    else if ("general" === input.kind)
+        return _io10(input);
+    else if ("utc" === input.kind)
+        return _io9(input);
+    else if ("utf8" === input.kind)
+        return _io8(input);
+    else if ("ia5" === input.kind)
+        return _io7(input);
+    else if ("printable" === input.kind)
+        return _io6(input);
+    else if ("struct" === input.type)
+        return _io11(input);
+    else
+        return (() => {
+            if (_io3(input))
+                return _io3(input);
+            if (_io13(input))
+                return _io13(input);
+            return false;
+        })();
+})(); const _it0 = input => null !== input[0] && undefined !== input[0] && ("function" === typeof input[0] || "bigint" === typeof input[0] || (Array.isArray(input[0]) && (_it0(input[0]) || false) || "object" === typeof input[0] && null !== input[0] && _iu0(input[0]))) && (Array.isArray(input.slice(1)) && input.slice(1).every(elem => null !== elem && undefined !== elem && ("function" === typeof elem || "bigint" === typeof elem || (Array.isArray(elem) && (_it0(elem) || false) || "object" === typeof elem && null !== elem && _iu0(elem))))); const _ao0 = (input, _path, _exceptionable = true) => false === _exceptionable || Object.keys(input).every(key => {
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return (null !== value || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+        method: "createAssert",
+        path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+        expected: "(__type | __type.o1 | __type.o10 | __type.o12 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
+        value: value
+    }, _errorFactory)) && (undefined !== value || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+        method: "createAssert",
+        path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+        expected: "(__type | __type.o1 | __type.o10 | __type.o12 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
+        value: value
+    }, _errorFactory)) && ("function" === typeof value || "bigint" === typeof value || (Array.isArray(value) && (_at0(value, _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key), true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+        method: "createAssert",
+        path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+        expected: "readonly [Schema, ...Schema[]]",
+        value: value
+    }, _errorFactory)) || "object" === typeof value && null !== value && _au1(value, _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key), true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+        method: "createAssert",
+        path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+        expected: "(__type | __type.o1 | __type.o10 | __type.o12 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
+        value: value
+    }, _errorFactory)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+        method: "createAssert",
+        path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+        expected: "(__type | __type.o1 | __type.o10 | __type.o12 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
+        value: value
+    }, _errorFactory));
+}); const _ao1 = (input, _path, _exceptionable = true) => (Array.isArray(input.choice) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".choice",
+    expected: "(Array<ValidateASN1.Schema> | ReadonlyArray<ValidateASN1.Schema>)",
+    value: input.choice
+}, _errorFactory)) && (_ap1(input.choice, _path + ".choice", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".choice",
+    expected: "Array<ValidateASN1.Schema> | ReadonlyArray<ValidateASN1.Schema>",
+    value: input.choice
+}, _errorFactory)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".choice",
+    expected: "(Array<ValidateASN1.Schema> | ReadonlyArray<ValidateASN1.Schema>)",
+    value: input.choice
+}, _errorFactory); const _ao2 = (input, _path, _exceptionable = true) => (null !== input.sequenceOf || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".sequenceOf",
+    expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
+    value: input.sequenceOf
+}, _errorFactory)) && (undefined !== input.sequenceOf || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".sequenceOf",
+    expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
+    value: input.sequenceOf
+}, _errorFactory)) && ("function" === typeof input.sequenceOf || "bigint" === typeof input.sequenceOf || (Array.isArray(input.sequenceOf) && (_at0(input.sequenceOf, _path + ".sequenceOf", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".sequenceOf",
+    expected: "readonly [Schema, ...Schema[]]",
+    value: input.sequenceOf
+}, _errorFactory)) || "object" === typeof input.sequenceOf && null !== input.sequenceOf && _au0(input.sequenceOf, _path + ".sequenceOf", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".sequenceOf",
+    expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
+    value: input.sequenceOf
+}, _errorFactory)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".sequenceOf",
+    expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
+    value: input.sequenceOf
+}, _errorFactory)); const _ao3 = (input, _path, _exceptionable = true) => (null !== input.optional || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".optional",
+    expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
+    value: input.optional
+}, _errorFactory)) && (undefined !== input.optional || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".optional",
+    expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
+    value: input.optional
+}, _errorFactory)) && ("function" === typeof input.optional || "bigint" === typeof input.optional || (Array.isArray(input.optional) && (_at0(input.optional, _path + ".optional", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".optional",
+    expected: "readonly [Schema, ...Schema[]]",
+    value: input.optional
+}, _errorFactory)) || "object" === typeof input.optional && null !== input.optional && _au0(input.optional, _path + ".optional", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".optional",
+    expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
+    value: input.optional
+}, _errorFactory)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".optional",
+    expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
+    value: input.optional
+}, _errorFactory)); const _ao4 = (input, _path, _exceptionable = true) => ("context" === input.type || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".type",
+    expected: "\"context\"",
+    value: input.type
+}, _errorFactory)) && ("implicit" === input.kind || "explicit" === input.kind || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".kind",
+    expected: "(\"explicit\" | \"implicit\")",
+    value: input.kind
+}, _errorFactory)) && ((null !== input.contains || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".contains",
+    expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
+    value: input.contains
+}, _errorFactory)) && (undefined !== input.contains || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".contains",
+    expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
+    value: input.contains
+}, _errorFactory)) && ("function" === typeof input.contains || "bigint" === typeof input.contains || (Array.isArray(input.contains) && (_at0(input.contains, _path + ".contains", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".contains",
+    expected: "readonly [Schema, ...Schema[]]",
+    value: input.contains
+}, _errorFactory)) || "object" === typeof input.contains && null !== input.contains && _au0(input.contains, _path + ".contains", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".contains",
+    expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
+    value: input.contains
+}, _errorFactory)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".contains",
+    expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
+    value: input.contains
+}, _errorFactory))) && ("number" === typeof input.value || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".value",
+    expected: "number",
+    value: input.value
+}, _errorFactory)); const _ao5 = (input, _path, _exceptionable = true) => ("oid" === input.type || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".type",
+    expected: "\"oid\"",
+    value: input.type
+}, _errorFactory)) && ("string" === typeof input.oid || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".oid",
+    expected: "string",
+    value: input.oid
+}, _errorFactory)); const _ao6 = (input, _path, _exceptionable = true) => ("string" === input.type || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".type",
+    expected: "\"string\"",
+    value: input.type
+}, _errorFactory)) && ("printable" === input.kind || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".kind",
+    expected: "\"printable\"",
+    value: input.kind
+}, _errorFactory)); const _ao7 = (input, _path, _exceptionable = true) => ("string" === input.type || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".type",
+    expected: "\"string\"",
+    value: input.type
+}, _errorFactory)) && ("ia5" === input.kind || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".kind",
+    expected: "\"ia5\"",
+    value: input.kind
+}, _errorFactory)); const _ao8 = (input, _path, _exceptionable = true) => ("string" === input.type || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".type",
+    expected: "\"string\"",
+    value: input.type
+}, _errorFactory)) && ("utf8" === input.kind || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".kind",
+    expected: "\"utf8\"",
+    value: input.kind
+}, _errorFactory)); const _ao9 = (input, _path, _exceptionable = true) => ("date" === input.type || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".type",
+    expected: "\"date\"",
+    value: input.type
+}, _errorFactory)) && ("utc" === input.kind || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".kind",
+    expected: "\"utc\"",
+    value: input.kind
+}, _errorFactory)); const _ao10 = (input, _path, _exceptionable = true) => ("date" === input.type || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".type",
+    expected: "\"date\"",
+    value: input.type
+}, _errorFactory)) && ("general" === input.kind || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".kind",
+    expected: "\"general\"",
+    value: input.kind
+}, _errorFactory)); const _ao11 = (input, _path, _exceptionable = true) => ("struct" === input.type || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".type",
+    expected: "\"struct\"",
+    value: input.type
+}, _errorFactory)) && ((Array.isArray(input.fieldNames) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".fieldNames",
+    expected: "Array<string>",
+    value: input.fieldNames
+}, _errorFactory)) && input.fieldNames.every((elem, _index11) => "string" === typeof elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".fieldNames[" + _index11 + "]",
+    expected: "string",
+    value: elem
+}, _errorFactory)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".fieldNames",
+    expected: "Array<string>",
+    value: input.fieldNames
+}, _errorFactory)) && (("object" === typeof input.contains && null !== input.contains && false === Array.isArray(input.contains) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".contains",
+    expected: "__type.o11",
+    value: input.contains
+}, _errorFactory)) && _ao12(input.contains, _path + ".contains", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".contains",
+    expected: "__type.o11",
+    value: input.contains
+}, _errorFactory)); const _ao12 = (input, _path, _exceptionable = true) => false === _exceptionable || Object.keys(input).every(key => {
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return (null !== value || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+        method: "createAssert",
+        path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+        expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
+        value: value
+    }, _errorFactory)) && (undefined !== value || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+        method: "createAssert",
+        path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+        expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
+        value: value
+    }, _errorFactory)) && ("function" === typeof value || "bigint" === typeof value || (Array.isArray(value) && (_at0(value, _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key), true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+        method: "createAssert",
+        path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+        expected: "readonly [Schema, ...Schema[]]",
+        value: value
+    }, _errorFactory)) || "object" === typeof value && null !== value && _au0(value, _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key), true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+        method: "createAssert",
+        path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+        expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
+        value: value
+    }, _errorFactory)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+        method: "createAssert",
+        path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+        expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
+        value: value
+    }, _errorFactory));
+}); const _ao13 = (input, _path, _exceptionable = true) => (null !== input.optional || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".optional",
+    expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
+    value: input.optional
+}, _errorFactory)) && (undefined !== input.optional || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".optional",
+    expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
+    value: input.optional
+}, _errorFactory)) && ("function" === typeof input.optional || "bigint" === typeof input.optional || (Array.isArray(input.optional) && (_at0(input.optional, _path + ".optional", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".optional",
+    expected: "readonly [Schema, ...Schema[]]",
+    value: input.optional
+}, _errorFactory)) || "object" === typeof input.optional && null !== input.optional && _au0(input.optional, _path + ".optional", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".optional",
+    expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
+    value: input.optional
+}, _errorFactory)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".optional",
+    expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
+    value: input.optional
+}, _errorFactory)); const _au0 = (input, _path, _exceptionable = true) => (() => {
+    if (undefined !== input.choice)
+        return _ao1(input, _path, true && _exceptionable);
+    else if (undefined !== input.sequenceOf)
+        return _ao2(input, _path, true && _exceptionable);
+    else if (undefined !== input.optional)
+        return _ao3(input, _path, true && _exceptionable);
+    else if ("context" === input.type)
+        return _ao4(input, _path, true && _exceptionable);
+    else if ("oid" === input.type)
+        return _ao5(input, _path, true && _exceptionable);
+    else if ("general" === input.kind)
+        return _ao10(input, _path, true && _exceptionable);
+    else if ("utc" === input.kind)
+        return _ao9(input, _path, true && _exceptionable);
+    else if ("utf8" === input.kind)
+        return _ao8(input, _path, true && _exceptionable);
+    else if ("ia5" === input.kind)
+        return _ao7(input, _path, true && _exceptionable);
+    else if ("printable" === input.kind)
+        return _ao6(input, _path, true && _exceptionable);
+    else if ("struct" === input.type)
+        return _ao11(input, _path, true && _exceptionable);
+    else
+        return __typia_transform__assertGuard._assertGuard(_exceptionable, {
+            method: "createAssert",
+            path: _path,
+            expected: "(__type | __type.o1 | __type.o2 | __type.o3 | __type.o4 | __type.o9 | __type.o8 | __type.o7 | __type.o6 | __type.o5 | __type.o10)",
+            value: input
+        }, _errorFactory);
+})(); const _au1 = (input, _path, _exceptionable = true) => (() => {
+    if (undefined !== input.choice)
+        return _ao1(input, _path, true && _exceptionable);
+    else if (undefined !== input.sequenceOf)
+        return _ao2(input, _path, true && _exceptionable);
+    else if ("context" === input.type)
+        return _ao4(input, _path, true && _exceptionable);
+    else if ("oid" === input.type)
+        return _ao5(input, _path, true && _exceptionable);
+    else if ("general" === input.kind)
+        return _ao10(input, _path, true && _exceptionable);
+    else if ("utc" === input.kind)
+        return _ao9(input, _path, true && _exceptionable);
+    else if ("utf8" === input.kind)
+        return _ao8(input, _path, true && _exceptionable);
+    else if ("ia5" === input.kind)
+        return _ao7(input, _path, true && _exceptionable);
+    else if ("printable" === input.kind)
+        return _ao6(input, _path, true && _exceptionable);
+    else if ("struct" === input.type)
+        return _ao11(input, _path, true && _exceptionable);
+    else
+        return _ao3(input, _path, false && _exceptionable) || _ao13(input, _path, false && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+            method: "createAssert",
+            path: _path,
+            expected: "(__type.o2 | __type.o12)",
+            value: input
+        }, _errorFactory);
+})(); const _at0 = (input, _path, _exceptionable = true) => (null !== input[0] || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + "[0]",
+    expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
+    value: input[0]
+}, _errorFactory)) && (undefined !== input[0] || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + "[0]",
+    expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
+    value: input[0]
+}, _errorFactory)) && ("function" === typeof input[0] || "bigint" === typeof input[0] || (Array.isArray(input[0]) && (_at0(input[0], _path + "[0]", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + "[0]",
+    expected: "readonly [Schema, ...Schema[]]",
+    value: input[0]
+}, _errorFactory)) || "object" === typeof input[0] && null !== input[0] && _au0(input[0], _path + "[0]", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + "[0]",
+    expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
+    value: input[0]
+}, _errorFactory)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + "[0]",
+    expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
+    value: input[0]
+}, _errorFactory)) && ((Array.isArray(input.slice(1)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path,
+    expected: "...(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
+    value: input.slice(1)
+}, _errorFactory)) && input.slice(1).every((elem, _index12) => (null !== elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + "[" + (1 + _index12) + "]",
+    expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
+    value: elem
+}, _errorFactory)) && (undefined !== elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + "[" + (1 + _index12) + "]",
+    expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
+    value: elem
+}, _errorFactory)) && ("function" === typeof elem || "bigint" === typeof elem || (Array.isArray(elem) && (_at0(elem, _path + "[" + (1 + _index12) + "]", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + "[" + (1 + _index12) + "]",
+    expected: "readonly [Schema, ...Schema[]]",
+    value: elem
+}, _errorFactory)) || "object" === typeof elem && null !== elem && _au0(elem, _path + "[" + (1 + _index12) + "]", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + "[" + (1 + _index12) + "]",
+    expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
+    value: elem
+}, _errorFactory)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + "[" + (1 + _index12) + "]",
+    expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
+    value: elem
+}, _errorFactory))) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path,
+    expected: "...(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
+    value: input.slice(1)
+}, _errorFactory)); 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: "StructFieldSchemaMap",
+            value: input
+        }, _errorFactory)) && _ao0(input, _path + "", true) || __typia_transform__assertGuard._assertGuard(true, {
+            method: "createAssert",
+            path: _path + "",
+            expected: "StructFieldSchemaMap",
+            value: input
+        }, _errorFactory))(input, "$input", true);
+    }
+    return input;
+}; })();
+const structSchemaGuard = (() => { const _ip0 = input => {
+    const array = input;
+    const top = input[0];
+    if (0 === input.length)
+        return true;
+    const arrayPredicators = [
+        [
+            top => null !== top && undefined !== top && ("function" === typeof top || "bigint" === typeof top || (Array.isArray(top) && (_it0(top) || false) || "object" === typeof top && null !== top && _iu0(top))),
+            entire => entire.every(elem => null !== elem && undefined !== elem && ("function" === typeof elem || "bigint" === typeof elem || (Array.isArray(elem) && (_it0(elem) || false) || "object" === typeof elem && null !== elem && _iu0(elem))))
+        ],
+        [
+            top => null !== top && undefined !== top && ("function" === typeof top || "bigint" === typeof top || (Array.isArray(top) && (_it0(top) || false) || "object" === typeof top && null !== top && _iu0(top))),
+            entire => entire.every(elem => null !== elem && undefined !== elem && ("function" === typeof elem || "bigint" === typeof elem || (Array.isArray(elem) && (_it0(elem) || false) || "object" === typeof elem && null !== elem && _iu0(elem))))
+        ]
+    ];
+    const passed = arrayPredicators.filter(pred => pred[0](top));
+    if (1 === passed.length)
+        return passed[0][1](array);
+    else if (1 < passed.length)
+        for (const pred of passed)
+            if (array.every(value => true === pred[0](value)))
+                return pred[1](array);
+    return false;
+}; const _io0 = input => "struct" === input.type && (Array.isArray(input.fieldNames) && input.fieldNames.every(elem => "string" === typeof elem)) && ("object" === typeof input.contains && null !== input.contains && false === Array.isArray(input.contains) && _io1(input.contains)); const _io1 = input => Object.keys(input).every(key => {
+    const value = input[key];
+    if (undefined === value)
+        return true;
+    return null !== value && undefined !== value && ("function" === typeof value || "bigint" === typeof value || (Array.isArray(value) && (_it0(value) || false) || "object" === typeof value && null !== value && _iu0(value)));
+}); const _io2 = input => Array.isArray(input.choice) && (_ip0(input.choice) || false); const _io3 = input => null !== input.sequenceOf && undefined !== input.sequenceOf && ("function" === typeof input.sequenceOf || "bigint" === typeof input.sequenceOf || (Array.isArray(input.sequenceOf) && (_it0(input.sequenceOf) || false) || "object" === typeof input.sequenceOf && null !== input.sequenceOf && _iu0(input.sequenceOf))); const _io4 = input => null !== input.optional && undefined !== input.optional && ("function" === typeof input.optional || "bigint" === typeof input.optional || (Array.isArray(input.optional) && (_it0(input.optional) || false) || "object" === typeof input.optional && null !== input.optional && _iu0(input.optional))); const _io5 = input => "context" === input.type && ("implicit" === input.kind || "explicit" === input.kind) && (null !== input.contains && undefined !== input.contains && ("function" === typeof input.contains || "bigint" === typeof input.contains || (Array.isArray(input.contains) && (_it0(input.contains) || false) || "object" === typeof input.contains && null !== input.contains && _iu0(input.contains)))) && "number" === typeof input.value; const _io6 = input => "oid" === input.type && "string" === typeof input.oid; const _io7 = input => "string" === input.type && "printable" === input.kind; const _io8 = input => "string" === input.type && "ia5" === input.kind; const _io9 = input => "string" === input.type && "utf8" === input.kind; const _io10 = input => "date" === input.type && "utc" === input.kind; const _io11 = input => "date" === input.type && "general" === input.kind; const _iu0 = input => (() => {
+    if (undefined !== input.choice)
+        return _io2(input);
+    else if (undefined !== input.sequenceOf)
+        return _io3(input);
+    else if (undefined !== input.optional)
+        return _io4(input);
+    else if ("context" === input.type)
+        return _io5(input);
+    else if ("oid" === input.type)
+        return _io6(input);
+    else if ("general" === input.kind)
+        return _io11(input);
+    else if ("utc" === input.kind)
+        return _io10(input);
+    else if ("utf8" === input.kind)
+        return _io9(input);
+    else if ("ia5" === input.kind)
+        return _io8(input);
+    else if ("printable" === input.kind)
+        return _io7(input);
+    else if ("struct" === input.type)
+        return _io0(input);
+    else
+        return false;
+})(); const _it0 = input => null !== input[0] && undefined !== input[0] && ("function" === typeof input[0] || "bigint" === typeof input[0] || (Array.isArray(input[0]) && (_it0(input[0]) || false) || "object" === typeof input[0] && null !== input[0] && _iu0(input[0]))) && (Array.isArray(input.slice(1)) && input.slice(1).every(elem => null !== elem && undefined !== elem && ("function" === typeof elem || "bigint" === typeof elem || (Array.isArray(elem) && (_it0(elem) || false) || "object" === typeof elem && null !== elem && _iu0(elem))))); return input => "object" === typeof input && null !== input && _io0(input); })();
+const structSchemaCache = new WeakMap();
+function defaultPrintValue(value) {
+    try {
+        return (JSON.stringify(value));
+    }
+    catch {
+        return (String(value));
+    }
+}
+function isOptionalSchema(candidate) {
+    return (typeof candidate === 'object' && candidate !== null && 'optional' in candidate);
+}
+function isStructSchema(candidate) {
+    return (structSchemaGuard(candidate));
+}
+function ensureStructContains(schema) {
+    if (!schema.contains) {
+        return ({});
+    }
+    return (assertStructFieldSchemaMap(schema.contains));
+}
+function isPlainObject(value) {
+    return (typeof value === 'object' && value !== null && !Array.isArray(value));
+}
+function getFieldNames(schema) {
+    return (Array.isArray(schema.fieldNames) && schema.fieldNames.length > 0
+        ? [...schema.fieldNames]
+        : Object.keys(ensureStructContains(schema)));
+}
+export function contextualizeStructSchema(schema) {
+    if (!isStructSchema(schema)) {
+        return (schema);
+    }
+    const cached = structSchemaCache.get(schema);
+    if (cached) {
+        return (cached);
+    }
+    const fieldNames = getFieldNames(schema);
+    const structContains = ensureStructContains(schema);
+    const contextualizedContains = {};
+    function wrapWithExplicitContext(index, innerSchema) {
+        if (typeof innerSchema === 'object' && innerSchema !== null && 'type' in innerSchema && innerSchema.type === 'context') {
+            return (innerSchema);
+        }
+        return ({
+            type: 'context',
+            kind: 'explicit',
+            value: index,
+            contains: contextualizeStructSchema(innerSchema)
+        });
+    }
+    for (const [index, fieldName] of fieldNames.entries()) {
+        const fieldSchema = structContains[fieldName];
+        if (!fieldSchema) {
+            continue;
+        }
+        if (isOptionalSchema(fieldSchema)) {
+            contextualizedContains[fieldName] = {
+                optional: wrapWithExplicitContext(index, fieldSchema.optional)
+            };
+            continue;
+        }
+        contextualizedContains[fieldName] = wrapWithExplicitContext(index, fieldSchema);
+    }
+    const contextualized = {
+        type: 'struct',
+        fieldNames,
+        contains: contextualizedContains
+    };
+    structSchemaCache.set(schema, contextualized);
+    return (contextualized);
+}
+function resolveSchema(schema) {
+    let current = schema;
+    while (typeof current === 'function') {
+        current = current();
+    }
+    return (current);
+}
+function prepareContextValue(schema, value, prepare) {
+    if (value === undefined) {
+        return (value);
+    }
+    if (isASN1ContextTag(value)) {
+        const preparedContains = prepare(schema.contains, value.contains);
+        if (preparedContains !== value.contains) {
+            return ({
+                type: 'context',
+                kind: value.kind,
+                value: value.value,
+                contains: preparedContains
+            });
+        }
+        return (value);
+    }
+    const contains = prepare(schema.contains, value);
+    return ({
+        type: 'context',
+        kind: schema.kind,
+        value: schema.value,
+        contains
+    });
+}
+function prepareStructValue(schema, value) {
+    const structContains = schema.contains ?? {};
+    const fieldNames = getFieldNames(schema);
+    if (isASN1Struct(value)) {
+        const preparedContains = {};
+        for (const [fieldName, fieldValue] of Object.entries(value.contains ?? {})) {
+            const fieldSchema = structContains[fieldName];
+            if (!fieldSchema) {
+                preparedContains[fieldName] = fieldValue;
+                continue;
+            }
+            const innerSchema = isOptionalSchema(fieldSchema) ? fieldSchema.optional : fieldSchema;
+            // eslint-disable-next-line @typescript-eslint/no-use-before-define
+            preparedContains[fieldName] = prepareValueForSchema(innerSchema, fieldValue);
+        }
+        return ({
+            type: 'struct',
+            fieldNames: value.fieldNames ?? fieldNames,
+            contains: preparedContains
+        });
+    }
+    if (!isPlainObject(value)) {
+        return (value);
+    }
+    const preparedContains = {};
+    for (const fieldName of fieldNames) {
+        const fieldSchema = structContains[fieldName];
+        if (!fieldSchema) {
+            continue;
+        }
+        const fieldValue = value[fieldName];
+        if (fieldValue === undefined) {
+            if (!isOptionalSchema(fieldSchema)) {
+                preparedContains[fieldName] = fieldValue;
+            }
+            continue;
+        }
+        const innerSchema = isOptionalSchema(fieldSchema) ? fieldSchema.optional : fieldSchema;
+        // eslint-disable-next-line @typescript-eslint/no-use-before-define
+        preparedContains[fieldName] = prepareValueForSchema(innerSchema, fieldValue);
+    }
+    return ({
+        type: 'struct',
+        fieldNames,
+        contains: preparedContains
+    });
+}
+function prepareValueForSchema(schema, value) {
+    const resolved = resolveSchema(schema);
+    if (value === undefined || value === null) {
+        return (value);
+    }
+    if (Array.isArray(resolved)) {
+        if (!Array.isArray(value)) {
+            return (value);
+        }
+        const result = [];
+        for (let i = 0; i < resolved.length; i++) {
+            result.push(prepareValueForSchema((() => { const _ip0 = input => {
+                const array = input;
+                const top = input[0];
+                if (0 === input.length)
+                    return true;
+                const arrayPredicators = [
+                    [
+                        top => null !== top && undefined !== top && ("function" === typeof top || "bigint" === typeof top || (Array.isArray(top) && (_it0(top) || false) || "object" === typeof top && null !== top && _iu0(top))),
+                        entire => entire.every(elem => null !== elem && undefined !== elem && ("function" === typeof elem || "bigint" === typeof elem || (Array.isArray(elem) && (_it0(elem) || false) || "object" === typeof elem && null !== elem && _iu0(elem))))
+                    ],
+                    [
+                        top => null !== top && undefined !== top && ("function" === typeof top || "bigint" === typeof top || (Array.isArray(top) && (_it0(top) || false) || "object" === typeof top && null !== top && _iu0(top))),
+                        entire => entire.every(elem => null !== elem && undefined !== elem && ("function" === typeof elem || "bigint" === typeof elem || (Array.isArray(elem) && (_it0(elem) || false) || "object" === typeof elem && null !== elem && _iu0(elem))))
+                    ]
+                ];
+                const passed = arrayPredicators.filter(pred => pred[0](top));
+                if (1 === passed.length)
+                    return passed[0][1](array);
+                else if (1 < passed.length)
+                    for (const pred of passed)
+                        if (array.every(value => true === pred[0](value)))
+                            return pred[1](array);
+                return false;
+            }; const _ap1 = (input, _path, _exceptionable = true) => {
+                const array = input;
+                const top = input[0];
+                if (0 === input.length)
+                    return true;
+                const arrayPredicators = [
+                    [
+                        top => null !== top && undefined !== top && ("function" === typeof top || "bigint" === typeof top || (Array.isArray(top) && (_at0(top, _path, false && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                            method: "assert",
+                            path: _path,
+                            expected: "readonly [Schema, ...Schema[]]",
+                            value: top
+                        }, _errorFactory)) || "object" === typeof top && null !== top && _au0(top, _path, false && _exceptionable))),
+                        entire => entire.every((elem, _index9) => (null !== elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                            method: "assert",
+                            path: _path + "[" + _index9 + "]",
+                            expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
+                            value: elem
+                        }, _errorFactory)) && (undefined !== elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                            method: "assert",
+                            path: _path + "[" + _index9 + "]",
+                            expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
+                            value: elem
+                        }, _errorFactory)) && ("function" === typeof elem || "bigint" === typeof elem || (Array.isArray(elem) && (_at0(elem, _path + "[" + _index9 + "]", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                            method: "assert",
+                            path: _path + "[" + _index9 + "]",
+                            expected: "readonly [Schema, ...Schema[]]",
+                            value: elem
+                        }, _errorFactory)) || "object" === typeof elem && null !== elem && _au0(elem, _path + "[" + _index9 + "]", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                            method: "assert",
+                            path: _path + "[" + _index9 + "]",
+                            expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
+                            value: elem
+                        }, _errorFactory)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                            method: "assert",
+                            path: _path + "[" + _index9 + "]",
+                            expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
+                            value: elem
+                        }, _errorFactory)))
+                    ],
+                    [
+                        top => null !== top && undefined !== top && ("function" === typeof top || "bigint" === typeof top || (Array.isArray(top) && (_at0(top, _path, false && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                            method: "assert",
+                            path: _path,
+                            expected: "readonly [Schema, ...Schema[]]",
+                            value: top
+                        }, _errorFactory)) || "object" === typeof top && null !== top && _au0(top, _path, false && _exceptionable))),
+                        entire => entire.every((elem, _index10) => (null !== elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                            method: "assert",
+                            path: _path + "[" + _index10 + "]",
+                            expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
+                            value: elem
+                        }, _errorFactory)) && (undefined !== elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                            method: "assert",
+                            path: _path + "[" + _index10 + "]",
+                            expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
+                            value: elem
+                        }, _errorFactory)) && ("function" === typeof elem || "bigint" === typeof elem || (Array.isArray(elem) && (_at0(elem, _path + "[" + _index10 + "]", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                            method: "assert",
+                            path: _path + "[" + _index10 + "]",
+                            expected: "readonly [Schema, ...Schema[]]",
+                            value: elem
+                        }, _errorFactory)) || "object" === typeof elem && null !== elem && _au0(elem, _path + "[" + _index10 + "]", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                            method: "assert",
+                            path: _path + "[" + _index10 + "]",
+                            expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
+                            value: elem
+                        }, _errorFactory)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                            method: "assert",
+                            path: _path + "[" + _index10 + "]",
+                            expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
+                            value: elem
+                        }, _errorFactory)))
+                    ]
+                ];
+                const passed = arrayPredicators.filter(pred => pred[0](top));
+                if (1 === passed.length)
+                    return passed[0][1](array);
+                else if (1 < passed.length)
+                    for (const pred of passed)
+                        if (array.every(value => true === pred[0](value)))
+                            return pred[1](array);
+                return __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                    method: "assert",
+                    path: _path,
+                    expected: "(Array<ValidateASN1.Schema> | ReadonlyArray<ValidateASN1.Schema>)",
+                    value: input
+                }, _errorFactory);
+            }; const _io0 = input => Array.isArray(input.choice) && (_ip0(input.choice) || false); const _io1 = input => null !== input.sequenceOf && undefined !== input.sequenceOf && ("function" === typeof input.sequenceOf || "bigint" === typeof input.sequenceOf || (Array.isArray(input.sequenceOf) && (_it0(input.sequenceOf) || false) || "object" === typeof input.sequenceOf && null !== input.sequenceOf && _iu0(input.sequenceOf))); const _io2 = input => null !== input.optional && undefined !== input.optional && ("function" === typeof input.optional || "bigint" === typeof input.optional || (Array.isArray(input.optional) && (_it0(input.optional) || false) || "object" === typeof input.optional && null !== input.optional && _iu0(input.optional))); const _io3 = input => "context" === input.type && ("implicit" === input.kind || "explicit" === input.kind) && (null !== input.contains && undefined !== input.contains && ("function" === typeof input.contains || "bigint" === typeof input.contains || (Array.isArray(input.contains) && (_it0(input.contains) || false) || "object" === typeof input.contains && null !== input.contains && _iu0(input.contains)))) && "number" === typeof input.value; const _io4 = input => "oid" === input.type && "string" === typeof input.oid; const _io5 = input => "string" === input.type && "printable" === input.kind; const _io6 = input => "string" === input.type && "ia5" === input.kind; const _io7 = input => "string" === input.type && "utf8" === input.kind; const _io8 = input => "date" === input.type && "utc" === input.kind; const _io9 = input => "date" === input.type && "general" === input.kind; const _io10 = input => "struct" === input.type && (Array.isArray(input.fieldNames) && input.fieldNames.every(elem => "string" === typeof elem)) && ("object" === typeof input.contains && null !== input.contains && false === Array.isArray(input.contains) && _io11(input.contains)); const _io11 = input => Object.keys(input).every(key => {
+                const value = input[key];
+                if (undefined === value)
+                    return true;
+                return null !== value && undefined !== value && ("function" === typeof value || "bigint" === typeof value || (Array.isArray(value) && (_it0(value) || false) || "object" === typeof value && null !== value && _iu0(value)));
+            }); const _iu0 = input => (() => {
+                if (undefined !== input.choice)
+                    return _io0(input);
+                else if (undefined !== input.sequenceOf)
+                    return _io1(input);
+                else if (undefined !== input.optional)
+                    return _io2(input);
+                else if ("context" === input.type)
+                    return _io3(input);
+                else if ("oid" === input.type)
+                    return _io4(input);
+                else if ("general" === input.kind)
+                    return _io9(input);
+                else if ("utc" === input.kind)
+                    return _io8(input);
+                else if ("utf8" === input.kind)
+                    return _io7(input);
+                else if ("ia5" === input.kind)
+                    return _io6(input);
+                else if ("printable" === input.kind)
+                    return _io5(input);
+                else if ("struct" === input.type)
+                    return _io10(input);
+                else
+                    return false;
+            })(); const _it0 = input => null !== input[0] && undefined !== input[0] && ("function" === typeof input[0] || "bigint" === typeof input[0] || (Array.isArray(input[0]) && (_it0(input[0]) || false) || "object" === typeof input[0] && null !== input[0] && _iu0(input[0]))) && (Array.isArray(input.slice(1)) && input.slice(1).every(elem => null !== elem && undefined !== elem && ("function" === typeof elem || "bigint" === typeof elem || (Array.isArray(elem) && (_it0(elem) || false) || "object" === typeof elem && null !== elem && _iu0(elem))))); const _ao0 = (input, _path, _exceptionable = true) => (Array.isArray(input.choice) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                method: "assert",
+                path: _path + ".choice",
+                expected: "(Array<ValidateASN1.Schema> | ReadonlyArray<ValidateASN1.Schema>)",
+                value: input.choice
+            }, _errorFactory)) && (_ap1(input.choice, _path + ".choice", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                method: "assert",
+                path: _path + ".choice",
+                expected: "Array<ValidateASN1.Schema> | ReadonlyArray<ValidateASN1.Schema>",
+                value: input.choice
+            }, _errorFactory)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                method: "assert",
+                path: _path + ".choice",
+                expected: "(Array<ValidateASN1.Schema> | ReadonlyArray<ValidateASN1.Schema>)",
+                value: input.choice
+            }, _errorFactory); const _ao1 = (input, _path, _exceptionable = true) => (null !== input.sequenceOf || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                method: "assert",
+                path: _path + ".sequenceOf",
+                expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
+                value: input.sequenceOf
+            }, _errorFactory)) && (undefined !== input.sequenceOf || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                method: "assert",
+                path: _path + ".sequenceOf",
+                expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
+                value: input.sequenceOf
+            }, _errorFactory)) && ("function" === typeof input.sequenceOf || "bigint" === typeof input.sequenceOf || (Array.isArray(input.sequenceOf) && (_at0(input.sequenceOf, _path + ".sequenceOf", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                method: "assert",
+                path: _path + ".sequenceOf",
+                expected: "readonly [Schema, ...Schema[]]",
+                value: input.sequenceOf
+            }, _errorFactory)) || "object" === typeof input.sequenceOf && null !== input.sequenceOf && _au0(input.sequenceOf, _path + ".sequenceOf", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                method: "assert",
+                path: _path + ".sequenceOf",
+                expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
+                value: input.sequenceOf
+            }, _errorFactory)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                method: "assert",
+                path: _path + ".sequenceOf",
+                expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
+                value: input.sequenceOf
+            }, _errorFactory)); const _ao2 = (input, _path, _exceptionable = true) => (null !== input.optional || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                method: "assert",
+                path: _path + ".optional",
+                expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
+                value: input.optional
+            }, _errorFactory)) && (undefined !== input.optional || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                method: "assert",
+                path: _path + ".optional",
+                expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
+                value: input.optional
+            }, _errorFactory)) && ("function" === typeof input.optional || "bigint" === typeof input.optional || (Array.isArray(input.optional) && (_at0(input.optional, _path + ".optional", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                method: "assert",
+                path: _path + ".optional",
+                expected: "readonly [Schema, ...Schema[]]",
+                value: input.optional
+            }, _errorFactory)) || "object" === typeof input.optional && null !== input.optional && _au0(input.optional, _path + ".optional", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                method: "assert",
+                path: _path + ".optional",
+                expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
+                value: input.optional
+            }, _errorFactory)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                method: "assert",
+                path: _path + ".optional",
+                expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
+                value: input.optional
+            }, _errorFactory)); const _ao3 = (input, _path, _exceptionable = true) => ("context" === input.type || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                method: "assert",
+                path: _path + ".type",
+                expected: "\"context\"",
+                value: input.type
+            }, _errorFactory)) && ("implicit" === input.kind || "explicit" === input.kind || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                method: "assert",
+                path: _path + ".kind",
+                expected: "(\"explicit\" | \"implicit\")",
+                value: input.kind
+            }, _errorFactory)) && ((null !== input.contains || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                method: "assert",
+                path: _path + ".contains",
+                expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
+                value: input.contains
+            }, _errorFactory)) && (undefined !== input.contains || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                method: "assert",
+                path: _path + ".contains",
+                expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
+                value: input.contains
+            }, _errorFactory)) && ("function" === typeof input.contains || "bigint" === typeof input.contains || (Array.isArray(input.contains) && (_at0(input.contains, _path + ".contains", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                method: "assert",
+                path: _path + ".contains",
+                expected: "readonly [Schema, ...Schema[]]",
+                value: input.contains
+            }, _errorFactory)) || "object" === typeof input.contains && null !== input.contains && _au0(input.contains, _path + ".contains", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                method: "assert",
+                path: _path + ".contains",
+                expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
+                value: input.contains
+            }, _errorFactory)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                method: "assert",
+                path: _path + ".contains",
+                expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
+                value: input.contains
+            }, _errorFactory))) && ("number" === typeof input.value || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                method: "assert",
+                path: _path + ".value",
+                expected: "number",
+                value: input.value
+            }, _errorFactory)); const _ao4 = (input, _path, _exceptionable = true) => ("oid" === input.type || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                method: "assert",
+                path: _path + ".type",
+                expected: "\"oid\"",
+                value: input.type
+            }, _errorFactory)) && ("string" === typeof input.oid || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                method: "assert",
+                path: _path + ".oid",
+                expected: "string",
+                value: input.oid
+            }, _errorFactory)); const _ao5 = (input, _path, _exceptionable = true) => ("string" === input.type || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                method: "assert",
+                path: _path + ".type",
+                expected: "\"string\"",
+                value: input.type
+            }, _errorFactory)) && ("printable" === input.kind || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                method: "assert",
+                path: _path + ".kind",
+                expected: "\"printable\"",
+                value: input.kind
+            }, _errorFactory)); const _ao6 = (input, _path, _exceptionable = true) => ("string" === input.type || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                method: "assert",
+                path: _path + ".type",
+                expected: "\"string\"",
+                value: input.type
+            }, _errorFactory)) && ("ia5" === input.kind || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                method: "assert",
+                path: _path + ".kind",
+                expected: "\"ia5\"",
+                value: input.kind
+            }, _errorFactory)); const _ao7 = (input, _path, _exceptionable = true) => ("string" === input.type || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                method: "assert",
+                path: _path + ".type",
+                expected: "\"string\"",
+                value: input.type
+            }, _errorFactory)) && ("utf8" === input.kind || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                method: "assert",
+                path: _path + ".kind",
+                expected: "\"utf8\"",
+                value: input.kind
+            }, _errorFactory)); const _ao8 = (input, _path, _exceptionable = true) => ("date" === input.type || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                method: "assert",
+                path: _path + ".type",
+                expected: "\"date\"",
+                value: input.type
+            }, _errorFactory)) && ("utc" === input.kind || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                method: "assert",
+                path: _path + ".kind",
+                expected: "\"utc\"",
+                value: input.kind
+            }, _errorFactory)); const _ao9 = (input, _path, _exceptionable = true) => ("date" === input.type || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                method: "assert",
+                path: _path + ".type",
+                expected: "\"date\"",
+                value: input.type
+            }, _errorFactory)) && ("general" === input.kind || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                method: "assert",
+                path: _path + ".kind",
+                expected: "\"general\"",
+                value: input.kind
+            }, _errorFactory)); const _ao10 = (input, _path, _exceptionable = true) => ("struct" === input.type || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                method: "assert",
+                path: _path + ".type",
+                expected: "\"struct\"",
+                value: input.type
+            }, _errorFactory)) && ((Array.isArray(input.fieldNames) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                method: "assert",
+                path: _path + ".fieldNames",
+                expected: "Array<string>",
+                value: input.fieldNames
+            }, _errorFactory)) && input.fieldNames.every((elem, _index11) => "string" === typeof elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                method: "assert",
+                path: _path + ".fieldNames[" + _index11 + "]",
+                expected: "string",
+                value: elem
+            }, _errorFactory)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                method: "assert",
+                path: _path + ".fieldNames",
+                expected: "Array<string>",
+                value: input.fieldNames
+            }, _errorFactory)) && (("object" === typeof input.contains && null !== input.contains && false === Array.isArray(input.contains) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                method: "assert",
+                path: _path + ".contains",
+                expected: "__type.o11",
+                value: input.contains
+            }, _errorFactory)) && _ao11(input.contains, _path + ".contains", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                method: "assert",
+                path: _path + ".contains",
+                expected: "__type.o11",
+                value: input.contains
+            }, _errorFactory)); const _ao11 = (input, _path, _exceptionable = true) => false === _exceptionable || Object.keys(input).every(key => {
+                const value = input[key];
+                if (undefined === value)
+                    return true;
+                return (null !== value || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                    method: "assert",
+                    path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+                    expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
+                    value: value
+                }, _errorFactory)) && (undefined !== value || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                    method: "assert",
+                    path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+                    expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
+                    value: value
+                }, _errorFactory)) && ("function" === typeof value || "bigint" === typeof value || (Array.isArray(value) && (_at0(value, _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key), true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                    method: "assert",
+                    path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+                    expected: "readonly [Schema, ...Schema[]]",
+                    value: value
+                }, _errorFactory)) || "object" === typeof value && null !== value && _au0(value, _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key), true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                    method: "assert",
+                    path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+                    expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
+                    value: value
+                }, _errorFactory)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                    method: "assert",
+                    path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+                    expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
+                    value: value
+                }, _errorFactory));
+            }); const _au0 = (input, _path, _exceptionable = true) => (() => {
+                if (undefined !== input.choice)
+                    return _ao0(input, _path, true && _exceptionable);
+                else if (undefined !== input.sequenceOf)
+                    return _ao1(input, _path, true && _exceptionable);
+                else if (undefined !== input.optional)
+                    return _ao2(input, _path, true && _exceptionable);
+                else if ("context" === input.type)
+                    return _ao3(input, _path, true && _exceptionable);
+                else if ("oid" === input.type)
+                    return _ao4(input, _path, true && _exceptionable);
+                else if ("general" === input.kind)
+                    return _ao9(input, _path, true && _exceptionable);
+                else if ("utc" === input.kind)
+                    return _ao8(input, _path, true && _exceptionable);
+                else if ("utf8" === input.kind)
+                    return _ao7(input, _path, true && _exceptionable);
+                else if ("ia5" === input.kind)
+                    return _ao6(input, _path, true && _exceptionable);
+                else if ("printable" === input.kind)
+                    return _ao5(input, _path, true && _exceptionable);
+                else if ("struct" === input.type)
+                    return _ao10(input, _path, true && _exceptionable);
+                else
+                    return __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                        method: "assert",
+                        path: _path,
+                        expected: "(__type | __type.o1 | __type.o2 | __type.o3 | __type.o4 | __type.o9 | __type.o8 | __type.o7 | __type.o6 | __type.o5 | __type.o10)",
+                        value: input
+                    }, _errorFactory);
+            })(); const _at0 = (input, _path, _exceptionable = true) => (null !== input[0] || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                method: "assert",
+                path: _path + "[0]",
+                expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
+                value: input[0]
+            }, _errorFactory)) && (undefined !== input[0] || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                method: "assert",
+                path: _path + "[0]",
+                expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
+                value: input[0]
+            }, _errorFactory)) && ("function" === typeof input[0] || "bigint" === typeof input[0] || (Array.isArray(input[0]) && (_at0(input[0], _path + "[0]", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                method: "assert",
+                path: _path + "[0]",
+                expected: "readonly [Schema, ...Schema[]]",
+                value: input[0]
+            }, _errorFactory)) || "object" === typeof input[0] && null !== input[0] && _au0(input[0], _path + "[0]", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                method: "assert",
+                path: _path + "[0]",
+                expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
+                value: input[0]
+            }, _errorFactory)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                method: "assert",
+                path: _path + "[0]",
+                expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
+                value: input[0]
+            }, _errorFactory)) && ((Array.isArray(input.slice(1)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                method: "assert",
+                path: _path,
+                expected: "...(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
+                value: input.slice(1)
+            }, _errorFactory)) && input.slice(1).every((elem, _index12) => (null !== elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                method: "assert",
+                path: _path + "[" + (1 + _index12) + "]",
+                expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
+                value: elem
+            }, _errorFactory)) && (undefined !== elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                method: "assert",
+                path: _path + "[" + (1 + _index12) + "]",
+                expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
+                value: elem
+            }, _errorFactory)) && ("function" === typeof elem || "bigint" === typeof elem || (Array.isArray(elem) && (_at0(elem, _path + "[" + (1 + _index12) + "]", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                method: "assert",
+                path: _path + "[" + (1 + _index12) + "]",
+                expected: "readonly [Schema, ...Schema[]]",
+                value: elem
+            }, _errorFactory)) || "object" === typeof elem && null !== elem && _au0(elem, _path + "[" + (1 + _index12) + "]", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                method: "assert",
+                path: _path + "[" + (1 + _index12) + "]",
+                expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
+                value: elem
+            }, _errorFactory)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                method: "assert",
+                path: _path + "[" + (1 + _index12) + "]",
+                expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
+                value: elem
+            }, _errorFactory))) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                method: "assert",
+                path: _path,
+                expected: "...(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
+                value: input.slice(1)
+            }, _errorFactory)); const __is = input => null !== input && undefined !== input && ("function" === typeof input || "bigint" === typeof input || (Array.isArray(input) && (_it0(input) || false) || "object" === typeof input && null !== input && _iu0(input))); let _errorFactory; return (input, errorFactory) => {
+                if (false === __is(input)) {
+                    _errorFactory = errorFactory;
+                    ((input, _path, _exceptionable = true) => (null !== input || __typia_transform__assertGuard._assertGuard(true, {
+                        method: "assert",
+                        path: _path + "",
+                        expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
+                        value: input
+                    }, _errorFactory)) && (undefined !== input || __typia_transform__assertGuard._assertGuard(true, {
+                        method: "assert",
+                        path: _path + "",
+                        expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
+                        value: input
+                    }, _errorFactory)) && ("function" === typeof input || "bigint" === typeof input || (Array.isArray(input) && (_at0(input, _path + "", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                        method: "assert",
+                        path: _path + "",
+                        expected: "readonly [Schema, ...Schema[]]",
+                        value: input
+                    }, _errorFactory)) || "object" === typeof input && null !== input && _au0(input, _path + "", true) || __typia_transform__assertGuard._assertGuard(true, {
+                        method: "assert",
+                        path: _path + "",
+                        expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
+                        value: input
+                    }, _errorFactory)) || __typia_transform__assertGuard._assertGuard(true, {
+                        method: "assert",
+                        path: _path + "",
+                        expected: "(__type | __type.o1 | __type.o10 | __type.o2 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
+                        value: input
+                    }, _errorFactory)))(input, "$input", true);
+                }
+                return input;
+            }; })()(resolved[i]), value[i]));
+        }
+        return (result);
+    }
+    if (typeof resolved === 'object' && resolved !== null) {
+        if ('optional' in resolved) {
+            if (value === undefined) {
+                return (undefined);
+            }
+            return (prepareValueForSchema(resolved.optional, value));
+        }
+        if ('sequenceOf' in resolved) {
+            if (!Array.isArray(value)) {
+                return (value);
+            }
+            return (value.map(item => prepareValueForSchema(resolved.sequenceOf, item)));
+        }
+        if ('choice' in resolved) {
+            const choices = Array.isArray(resolved.choice)
+                ? resolved.choice
+                : Array.from(resolved.choice);
+            for (const choiceSchema of choices) {
+                const preparedChoice = prepareValueForSchema(choiceSchema, value);
+                if (preparedChoice !== value) {
+                    return (preparedChoice);
+                }
+            }
+            return (value);
+        }
+        if ('type' in resolved) {
+            switch (resolved.type) {
+                case 'context':
+                    return (prepareContextValue(resolved, value, prepareValueForSchema));
+                case 'struct':
+                    return (prepareStructValue(resolved, value));
+                default:
+                    return (value);
+            }
+        }
+    }
+    return (value);
+}
+export function encodeValueBySchema(schema, value, options) {
+    const contextualized = contextualizeStructSchema(schema);
+    try {
+        const preparedUnknown = prepareValueForSchema(contextualized, value);
+        // XXX:TODO Fix depth issue
+        // @ts-ignore
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/consistent-type-assertions
+        return (ValidateASN1.againstSchema(preparedUnknown, contextualized));
+    }
+    catch (err) {
+        const printer = options?.valuePrinter ?? defaultPrintValue;
+        const prefix = options?.attributeName ? `Attribute ${options.attributeName}: ` : '';
+        const message = err instanceof Error ? err.message : String(err);
+        throw (new Error(`${prefix}${message} (value: ${printer(value)})`));
+    }
+}
+export function normalizeDecodedASN1(input) {
+    if (input === undefined || input === null) {
+        return (input);
+    }
+    if (Array.isArray(input)) {
+        return (input.map(normalizeDecodedASN1));
+    }
+    if (input instanceof Date) {
+        return (input);
+    }
+    if (Buffer.isBuffer(input) || input instanceof ArrayBuffer) {
+        return (input);
+    }
+    if (isASN1ContextTag(input)) {
+        return (normalizeDecodedASN1(input.contains));
+    }
+    if (isASN1String(input)) {
+        return (normalizeDecodedASN1(input.value));
+    }
+    if (isASN1Date(input)) {
+        return (input.date);
+    }
+    if (isASN1BitString(input)) {
+        return (input.value);
+    }
+    if (isASN1Struct(input)) {
+        const contains = input.contains ?? {};
+        const orderedNames = Array.isArray(input.fieldNames) && input.fieldNames.length > 0
+            ? input.fieldNames
+            : Object.keys(contains);
+        const result = {};
+        for (const fieldName of orderedNames) {
+            if (!Object.prototype.hasOwnProperty.call(contains, fieldName)) {
+                continue;
+            }
+            const fieldValue = contains[fieldName];
+            if (fieldValue !== undefined) {
+                result[fieldName] = normalizeDecodedASN1(fieldValue);
+            }
+        }
+        return (result);
+    }
+    if (isASN1Set(input)) {
+        return ({
+            name: normalizeDecodedASN1(input.name),
+            value: normalizeDecodedASN1(input.value)
+        });
+    }
+    if (isPlainObject(input)) {
+        const result = {};
+        for (const [key, value] of Object.entries(input)) {
+            result[key] = normalizeDecodedASN1(value);
+        }
+        return (result);
+    }
+    return (input);
+}
 export { ASN1toJS, JStoASN1, BufferStorageASN1, ValidateASN1 };
 //# sourceMappingURL=asn1.js.map