@keetanetwork/anchor 0.0.24 → 0.0.26

package/lib/utils/asn1.js

@@ -1,8 +1,1981 @@
+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 { isReferenceSchema } from './asn1.generated.js';
+import { EncryptedContainer } from '../encrypted-container.js';
+import { Buffer, bufferToArrayBuffer } from './buffer.js';
+import { checkHashWithOID } from './external.js';
+const KeetaNetAccount = KeetaNetLib.Account;
+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 _ip1 = input => {
+    const array = input;
+    const top = input[0];
+    if (0 === input.length)
+        return true;
+    const arrayPredicators = [
+        [
+            top => "string" === typeof top,
+            entire => entire.every(elem => "string" === typeof elem)
+        ],
+        [
+            top => "string" === typeof top,
+            entire => entire.every(elem => "string" === typeof 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 _ap2 = (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, _index16) => (null !== elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                method: "createAssert",
+                path: _path + "[" + _index16 + "]",
+                expected: "(__type | __type.o1 | __type.o10 | __type.o11 | __type.o12 | __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 + "[" + _index16 + "]",
+                expected: "(__type | __type.o1 | __type.o10 | __type.o11 | __type.o12 | __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 + "[" + _index16 + "]", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                method: "createAssert",
+                path: _path + "[" + _index16 + "]",
+                expected: "readonly [Schema, ...Schema[]]",
+                value: elem
+            }, _errorFactory)) || "object" === typeof elem && null !== elem && _au0(elem, _path + "[" + _index16 + "]", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                method: "createAssert",
+                path: _path + "[" + _index16 + "]",
+                expected: "(__type | __type.o1 | __type.o10 | __type.o11 | __type.o12 | __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 + "[" + _index16 + "]",
+                expected: "(__type | __type.o1 | __type.o10 | __type.o11 | __type.o12 | __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, _index17) => (null !== elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                method: "createAssert",
+                path: _path + "[" + _index17 + "]",
+                expected: "(__type | __type.o1 | __type.o10 | __type.o11 | __type.o12 | __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 + "[" + _index17 + "]",
+                expected: "(__type | __type.o1 | __type.o10 | __type.o11 | __type.o12 | __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 + "[" + _index17 + "]", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                method: "createAssert",
+                path: _path + "[" + _index17 + "]",
+                expected: "readonly [Schema, ...Schema[]]",
+                value: elem
+            }, _errorFactory)) || "object" === typeof elem && null !== elem && _au0(elem, _path + "[" + _index17 + "]", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                method: "createAssert",
+                path: _path + "[" + _index17 + "]",
+                expected: "(__type | __type.o1 | __type.o10 | __type.o11 | __type.o12 | __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 + "[" + _index17 + "]",
+                expected: "(__type | __type.o1 | __type.o10 | __type.o11 | __type.o12 | __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: "(ReadonlyArray<ValidateASN1.Schema> | Array<ValidateASN1.Schema>)",
+        value: input
+    }, _errorFactory);
+}; const _ap3 = (input, _path, _exceptionable = true) => {
+    const array = input;
+    const top = input[0];
+    if (0 === input.length)
+        return true;
+    const arrayPredicators = [
+        [
+            top => "string" === typeof top,
+            entire => entire.every((elem, _index20) => "string" === typeof elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                method: "createAssert",
+                path: _path + "[" + _index20 + "]",
+                expected: "string",
+                value: elem
+            }, _errorFactory))
+        ],
+        [
+            top => "string" === typeof top,
+            entire => entire.every((elem, _index21) => "string" === typeof elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                method: "createAssert",
+                path: _path + "[" + _index21 + "]",
+                expected: "string",
+                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<string> | ReadonlyArray<string>)",
+        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 => "object" === typeof input.choice && null !== input.choice && false === Array.isArray(input.choice) && _iu2(input.choice); const _io3 = 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 _io4 = 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 _io5 = 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 _io6 = 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 _io7 = input => "oid" === input.type && "string" === typeof input.oid; const _io8 = input => "string" === input.type && "printable" === input.kind; const _io9 = input => "string" === input.type && "ia5" === input.kind; const _io10 = input => "string" === input.type && "utf8" === input.kind; const _io11 = input => "date" === input.type && "utc" === input.kind; const _io12 = input => "date" === input.type && "general" === input.kind; const _io13 = input => "struct" === input.type && (Array.isArray(input.fieldNames) && (_ip1(input.fieldNames) || false)) && ("object" === typeof input.contains && null !== input.contains && false === Array.isArray(input.contains) && _iu3(input.contains)); const _io14 = 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 _io15 = 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 _io16 = 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 _io17 = 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 ("object" === typeof input.choice && null !== input.choice && false === Array.isArray(input.choice) && _iu2(input.choice))
+        return _io2(input);
+    else if (Array.isArray(input.choice) && (_ip0(input.choice) || false))
+        return _io1(input);
+    else if (undefined !== input.sequenceOf)
+        return _io4(input);
+    else if (undefined !== input.optional)
+        return _io5(input);
+    else if ("context" === input.type)
+        return _io6(input);
+    else if ("oid" === input.type)
+        return _io7(input);
+    else if ("general" === input.kind)
+        return _io12(input);
+    else if ("utc" === input.kind)
+        return _io11(input);
+    else if ("utf8" === input.kind)
+        return _io10(input);
+    else if ("ia5" === input.kind)
+        return _io9(input);
+    else if ("printable" === input.kind)
+        return _io8(input);
+    else if ("struct" === input.type)
+        return _io13(input);
+    else
+        return false;
+})(); const _iu1 = input => (() => {
+    if ("object" === typeof input.choice && null !== input.choice && false === Array.isArray(input.choice) && _iu2(input.choice))
+        return _io2(input);
+    else if (Array.isArray(input.choice) && (_ip0(input.choice) || false))
+        return _io1(input);
+    else if (undefined !== input.sequenceOf)
+        return _io4(input);
+    else if ("context" === input.type)
+        return _io6(input);
+    else if ("oid" === input.type)
+        return _io7(input);
+    else if ("general" === input.kind)
+        return _io12(input);
+    else if ("utc" === input.kind)
+        return _io11(input);
+    else if ("utf8" === input.kind)
+        return _io10(input);
+    else if ("ia5" === input.kind)
+        return _io9(input);
+    else if ("printable" === input.kind)
+        return _io8(input);
+    else if ("struct" === input.type)
+        return _io13(input);
+    else
+        return (() => {
+            if (_io5(input))
+                return _io5(input);
+            if (_io17(input))
+                return _io17(input);
+            return false;
+        })();
+})(); const _iu2 = input => (() => {
+    if (_io16(input))
+        return _io16(input);
+    if (_io3(input))
+        return _io3(input);
+    return false;
+})(); const _iu3 = input => (() => {
+    if (_io15(input))
+        return _io15(input);
+    if (_io14(input))
+        return _io14(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.o11 | __type.o12 | __type.o16 | __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.o11 | __type.o12 | __type.o16 | __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.o11 | __type.o12 | __type.o16 | __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.o11 | __type.o12 | __type.o16 | __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)) && (_ap2(input.choice, _path + ".choice", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".choice",
+    expected: "ReadonlyArray<ValidateASN1.Schema> | Array<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) => ("object" === typeof input.choice && null !== input.choice && false === Array.isArray(input.choice) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".choice",
+    expected: "(__type.o15 | __type.o2)",
+    value: input.choice
+}, _errorFactory)) && _au2(input.choice, _path + ".choice", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".choice",
+    expected: "(__type.o15 | __type.o2)",
+    value: input.choice
+}, _errorFactory); const _ao3 = (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.o11 | __type.o12 | __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.o11 | __type.o12 | __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.o11 | __type.o12 | __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.o11 | __type.o12 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
+        value: value
+    }, _errorFactory));
+}); const _ao4 = (input, _path, _exceptionable = true) => (null !== input.sequenceOf || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".sequenceOf",
+    expected: "(__type | __type.o1 | __type.o10 | __type.o11 | __type.o12 | __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.o11 | __type.o12 | __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.o11 | __type.o12 | __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.o11 | __type.o12 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
+    value: input.sequenceOf
+}, _errorFactory)); const _ao5 = (input, _path, _exceptionable = true) => (null !== input.optional || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".optional",
+    expected: "(__type | __type.o1 | __type.o10 | __type.o11 | __type.o12 | __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.o11 | __type.o12 | __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.o11 | __type.o12 | __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.o11 | __type.o12 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
+    value: input.optional
+}, _errorFactory)); const _ao6 = (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.o11 | __type.o12 | __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.o11 | __type.o12 | __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.o11 | __type.o12 | __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.o11 | __type.o12 | __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 _ao7 = (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 _ao8 = (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 _ao9 = (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 _ao10 = (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 _ao11 = (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 _ao12 = (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 _ao13 = (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> | ReadonlyArray<string>)",
+    value: input.fieldNames
+}, _errorFactory)) && (_ap3(input.fieldNames, _path + ".fieldNames", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".fieldNames",
+    expected: "Array<string> | ReadonlyArray<string>",
+    value: input.fieldNames
+}, _errorFactory)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".fieldNames",
+    expected: "(Array<string> | ReadonlyArray<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.o13 | __type.o14)",
+    value: input.contains
+}, _errorFactory)) && _au3(input.contains, _path + ".contains", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".contains",
+    expected: "(__type.o13 | __type.o14)",
+    value: input.contains
+}, _errorFactory)); const _ao14 = (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.o11 | __type.o12 | __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.o11 | __type.o12 | __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.o11 | __type.o12 | __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.o11 | __type.o12 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
+        value: value
+    }, _errorFactory));
+}); const _ao15 = (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.o11 | __type.o12 | __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.o11 | __type.o12 | __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.o11 | __type.o12 | __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.o11 | __type.o12 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
+        value: value
+    }, _errorFactory));
+}); const _ao16 = (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.o11 | __type.o12 | __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.o11 | __type.o12 | __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.o11 | __type.o12 | __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.o11 | __type.o12 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
+        value: value
+    }, _errorFactory));
+}); const _ao17 = (input, _path, _exceptionable = true) => (null !== input.optional || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + ".optional",
+    expected: "(__type | __type.o1 | __type.o10 | __type.o11 | __type.o12 | __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.o11 | __type.o12 | __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.o11 | __type.o12 | __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.o11 | __type.o12 | __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 ("object" === typeof input.choice && null !== input.choice && false === Array.isArray(input.choice) && _au2(input.choice, _path + ".choice", false && _exceptionable))
+        return _ao2(input, _path, true && _exceptionable);
+    else if (Array.isArray(input.choice) && (_ap2(input.choice, _path + ".choice", false && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+        method: "createAssert",
+        path: _path + ".choice",
+        expected: "ReadonlyArray<ValidateASN1.Schema> | Array<ValidateASN1.Schema>",
+        value: input.choice
+    }, _errorFactory)))
+        return _ao1(input, _path, true && _exceptionable);
+    else if (undefined !== input.sequenceOf)
+        return _ao4(input, _path, true && _exceptionable);
+    else if (undefined !== input.optional)
+        return _ao5(input, _path, true && _exceptionable);
+    else if ("context" === input.type)
+        return _ao6(input, _path, true && _exceptionable);
+    else if ("oid" === input.type)
+        return _ao7(input, _path, true && _exceptionable);
+    else if ("general" === input.kind)
+        return _ao12(input, _path, true && _exceptionable);
+    else if ("utc" === input.kind)
+        return _ao11(input, _path, true && _exceptionable);
+    else if ("utf8" === input.kind)
+        return _ao10(input, _path, true && _exceptionable);
+    else if ("ia5" === input.kind)
+        return _ao9(input, _path, true && _exceptionable);
+    else if ("printable" === input.kind)
+        return _ao8(input, _path, true && _exceptionable);
+    else if ("struct" === input.type)
+        return _ao13(input, _path, true && _exceptionable);
+    else
+        return __typia_transform__assertGuard._assertGuard(_exceptionable, {
+            method: "createAssert",
+            path: _path,
+            expected: "(__type.o1 | __type | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o11 | __type.o10 | __type.o9 | __type.o8 | __type.o7 | __type.o12)",
+            value: input
+        }, _errorFactory);
+})(); const _au1 = (input, _path, _exceptionable = true) => (() => {
+    if ("object" === typeof input.choice && null !== input.choice && false === Array.isArray(input.choice) && _au2(input.choice, _path + ".choice", false && _exceptionable))
+        return _ao2(input, _path, true && _exceptionable);
+    else if (Array.isArray(input.choice) && (_ap2(input.choice, _path + ".choice", false && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+        method: "createAssert",
+        path: _path + ".choice",
+        expected: "ReadonlyArray<ValidateASN1.Schema> | Array<ValidateASN1.Schema>",
+        value: input.choice
+    }, _errorFactory)))
+        return _ao1(input, _path, true && _exceptionable);
+    else if (undefined !== input.sequenceOf)
+        return _ao4(input, _path, true && _exceptionable);
+    else if ("context" === input.type)
+        return _ao6(input, _path, true && _exceptionable);
+    else if ("oid" === input.type)
+        return _ao7(input, _path, true && _exceptionable);
+    else if ("general" === input.kind)
+        return _ao12(input, _path, true && _exceptionable);
+    else if ("utc" === input.kind)
+        return _ao11(input, _path, true && _exceptionable);
+    else if ("utf8" === input.kind)
+        return _ao10(input, _path, true && _exceptionable);
+    else if ("ia5" === input.kind)
+        return _ao9(input, _path, true && _exceptionable);
+    else if ("printable" === input.kind)
+        return _ao8(input, _path, true && _exceptionable);
+    else if ("struct" === input.type)
+        return _ao13(input, _path, true && _exceptionable);
+    else
+        return _ao5(input, _path, false && _exceptionable) || _ao17(input, _path, false && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+            method: "createAssert",
+            path: _path,
+            expected: "(__type.o4 | __type.o16)",
+            value: input
+        }, _errorFactory);
+})(); const _au2 = (input, _path, _exceptionable = true) => _ao16(input, _path, false && _exceptionable) || _ao3(input, _path, false && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path,
+    expected: "(__type.o15 | __type.o2)",
+    value: input
+}, _errorFactory); const _au3 = (input, _path, _exceptionable = true) => _ao15(input, _path, false && _exceptionable) || _ao14(input, _path, false && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path,
+    expected: "(__type.o14 | __type.o13)",
+    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.o11 | __type.o12 | __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.o11 | __type.o12 | __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.o11 | __type.o12 | __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.o11 | __type.o12 | __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.o11 | __type.o12 | __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, _index26) => (null !== elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + "[" + (1 + _index26) + "]",
+    expected: "(__type | __type.o1 | __type.o10 | __type.o11 | __type.o12 | __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 + _index26) + "]",
+    expected: "(__type | __type.o1 | __type.o10 | __type.o11 | __type.o12 | __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 + _index26) + "]", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + "[" + (1 + _index26) + "]",
+    expected: "readonly [Schema, ...Schema[]]",
+    value: elem
+}, _errorFactory)) || "object" === typeof elem && null !== elem && _au0(elem, _path + "[" + (1 + _index26) + "]", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    method: "createAssert",
+    path: _path + "[" + (1 + _index26) + "]",
+    expected: "(__type | __type.o1 | __type.o10 | __type.o11 | __type.o12 | __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 + _index26) + "]",
+    expected: "(__type | __type.o1 | __type.o10 | __type.o11 | __type.o12 | __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.o11 | __type.o12 | __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 => "string" === typeof top,
+            entire => entire.every(elem => "string" === typeof elem)
+        ],
+        [
+            top => "string" === typeof top,
+            entire => entire.every(elem => "string" === typeof 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 _ip1 = 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) && (_ip0(input.fieldNames) || false)) && ("object" === typeof input.contains && null !== input.contains && false === Array.isArray(input.contains) && _iu1(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) && (_ip1(input.choice) || false); const _io3 = input => "object" === typeof input.choice && null !== input.choice && false === Array.isArray(input.choice) && _iu2(input.choice); const _io4 = 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 _io5 = 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 _io6 = 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 _io7 = 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 _io8 = input => "oid" === input.type && "string" === typeof input.oid; const _io9 = input => "string" === input.type && "printable" === input.kind; const _io10 = input => "string" === input.type && "ia5" === input.kind; const _io11 = input => "string" === input.type && "utf8" === input.kind; const _io12 = input => "date" === input.type && "utc" === input.kind; const _io13 = input => "date" === input.type && "general" === input.kind; const _io14 = 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 _io15 = 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 ("object" === typeof input.choice && null !== input.choice && false === Array.isArray(input.choice) && _iu2(input.choice))
+        return _io3(input);
+    else if (Array.isArray(input.choice) && (_ip1(input.choice) || false))
+        return _io2(input);
+    else if (undefined !== input.sequenceOf)
+        return _io5(input);
+    else if (undefined !== input.optional)
+        return _io6(input);
+    else if ("context" === input.type)
+        return _io7(input);
+    else if ("oid" === input.type)
+        return _io8(input);
+    else if ("general" === input.kind)
+        return _io13(input);
+    else if ("utc" === input.kind)
+        return _io12(input);
+    else if ("utf8" === input.kind)
+        return _io11(input);
+    else if ("ia5" === input.kind)
+        return _io10(input);
+    else if ("printable" === input.kind)
+        return _io9(input);
+    else if ("struct" === input.type)
+        return _io0(input);
+    else
+        return false;
+})(); const _iu1 = input => (() => {
+    if (_io15(input))
+        return _io15(input);
+    if (_io1(input))
+        return _io1(input);
+    return false;
+})(); const _iu2 = input => (() => {
+    if (_io14(input))
+        return _io14(input);
+    if (_io4(input))
+        return _io4(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))))); 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 _ip1 = input => {
+                const array = input;
+                const top = input[0];
+                if (0 === input.length)
+                    return true;
+                const arrayPredicators = [
+                    [
+                        top => "string" === typeof top,
+                        entire => entire.every(elem => "string" === typeof elem)
+                    ],
+                    [
+                        top => "string" === typeof top,
+                        entire => entire.every(elem => "string" === typeof 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 _ap2 = (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, _index14) => (null !== elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                            method: "assert",
+                            path: _path + "[" + _index14 + "]",
+                            expected: "(__type | __type.o1 | __type.o10 | __type.o11 | __type.o12 | __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 + "[" + _index14 + "]",
+                            expected: "(__type | __type.o1 | __type.o10 | __type.o11 | __type.o12 | __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 + "[" + _index14 + "]", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                            method: "assert",
+                            path: _path + "[" + _index14 + "]",
+                            expected: "readonly [Schema, ...Schema[]]",
+                            value: elem
+                        }, _errorFactory)) || "object" === typeof elem && null !== elem && _au0(elem, _path + "[" + _index14 + "]", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                            method: "assert",
+                            path: _path + "[" + _index14 + "]",
+                            expected: "(__type | __type.o1 | __type.o10 | __type.o11 | __type.o12 | __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 + "[" + _index14 + "]",
+                            expected: "(__type | __type.o1 | __type.o10 | __type.o11 | __type.o12 | __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, _index15) => (null !== elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                            method: "assert",
+                            path: _path + "[" + _index15 + "]",
+                            expected: "(__type | __type.o1 | __type.o10 | __type.o11 | __type.o12 | __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 + "[" + _index15 + "]",
+                            expected: "(__type | __type.o1 | __type.o10 | __type.o11 | __type.o12 | __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 + "[" + _index15 + "]", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                            method: "assert",
+                            path: _path + "[" + _index15 + "]",
+                            expected: "readonly [Schema, ...Schema[]]",
+                            value: elem
+                        }, _errorFactory)) || "object" === typeof elem && null !== elem && _au0(elem, _path + "[" + _index15 + "]", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                            method: "assert",
+                            path: _path + "[" + _index15 + "]",
+                            expected: "(__type | __type.o1 | __type.o10 | __type.o11 | __type.o12 | __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 + "[" + _index15 + "]",
+                            expected: "(__type | __type.o1 | __type.o10 | __type.o11 | __type.o12 | __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: "(ReadonlyArray<ValidateASN1.Schema> | Array<ValidateASN1.Schema>)",
+                    value: input
+                }, _errorFactory);
+            }; const _ap3 = (input, _path, _exceptionable = true) => {
+                const array = input;
+                const top = input[0];
+                if (0 === input.length)
+                    return true;
+                const arrayPredicators = [
+                    [
+                        top => "string" === typeof top,
+                        entire => entire.every((elem, _index18) => "string" === typeof elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                            method: "assert",
+                            path: _path + "[" + _index18 + "]",
+                            expected: "string",
+                            value: elem
+                        }, _errorFactory))
+                    ],
+                    [
+                        top => "string" === typeof top,
+                        entire => entire.every((elem, _index19) => "string" === typeof elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                            method: "assert",
+                            path: _path + "[" + _index19 + "]",
+                            expected: "string",
+                            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<string> | ReadonlyArray<string>)",
+                    value: input
+                }, _errorFactory);
+            }; const _io0 = input => Array.isArray(input.choice) && (_ip0(input.choice) || false); const _io1 = input => "object" === typeof input.choice && null !== input.choice && false === Array.isArray(input.choice) && _iu1(input.choice); const _io2 = 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 _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 _io12 = input => "struct" === input.type && (Array.isArray(input.fieldNames) && (_ip1(input.fieldNames) || false)) && ("object" === typeof input.contains && null !== input.contains && false === Array.isArray(input.contains) && _iu2(input.contains)); const _io13 = 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 _io14 = 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 _io15 = 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 ("object" === typeof input.choice && null !== input.choice && false === Array.isArray(input.choice) && _iu1(input.choice))
+                    return _io1(input);
+                else if (Array.isArray(input.choice) && (_ip0(input.choice) || false))
+                    return _io0(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 _io12(input);
+                else
+                    return false;
+            })(); const _iu1 = input => (() => {
+                if (_io15(input))
+                    return _io15(input);
+                if (_io2(input))
+                    return _io2(input);
+                return false;
+            })(); const _iu2 = input => (() => {
+                if (_io14(input))
+                    return _io14(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) => (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)) && (_ap2(input.choice, _path + ".choice", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                method: "assert",
+                path: _path + ".choice",
+                expected: "ReadonlyArray<ValidateASN1.Schema> | Array<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) => ("object" === typeof input.choice && null !== input.choice && false === Array.isArray(input.choice) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                method: "assert",
+                path: _path + ".choice",
+                expected: "(__type.o15 | __type.o2)",
+                value: input.choice
+            }, _errorFactory)) && _au1(input.choice, _path + ".choice", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                method: "assert",
+                path: _path + ".choice",
+                expected: "(__type.o15 | __type.o2)",
+                value: input.choice
+            }, _errorFactory); const _ao2 = (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.o11 | __type.o12 | __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.o11 | __type.o12 | __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.o11 | __type.o12 | __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.o11 | __type.o12 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
+                    value: value
+                }, _errorFactory));
+            }); const _ao3 = (input, _path, _exceptionable = true) => (null !== input.sequenceOf || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                method: "assert",
+                path: _path + ".sequenceOf",
+                expected: "(__type | __type.o1 | __type.o10 | __type.o11 | __type.o12 | __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.o11 | __type.o12 | __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.o11 | __type.o12 | __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.o11 | __type.o12 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
+                value: input.sequenceOf
+            }, _errorFactory)); const _ao4 = (input, _path, _exceptionable = true) => (null !== input.optional || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                method: "assert",
+                path: _path + ".optional",
+                expected: "(__type | __type.o1 | __type.o10 | __type.o11 | __type.o12 | __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.o11 | __type.o12 | __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.o11 | __type.o12 | __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.o11 | __type.o12 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
+                value: input.optional
+            }, _errorFactory)); const _ao5 = (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.o11 | __type.o12 | __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.o11 | __type.o12 | __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.o11 | __type.o12 | __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.o11 | __type.o12 | __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 _ao6 = (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 _ao7 = (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 _ao8 = (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 _ao9 = (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 _ao10 = (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 _ao11 = (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 _ao12 = (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> | ReadonlyArray<string>)",
+                value: input.fieldNames
+            }, _errorFactory)) && (_ap3(input.fieldNames, _path + ".fieldNames", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                method: "assert",
+                path: _path + ".fieldNames",
+                expected: "Array<string> | ReadonlyArray<string>",
+                value: input.fieldNames
+            }, _errorFactory)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                method: "assert",
+                path: _path + ".fieldNames",
+                expected: "(Array<string> | ReadonlyArray<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.o13 | __type.o14)",
+                value: input.contains
+            }, _errorFactory)) && _au2(input.contains, _path + ".contains", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                method: "assert",
+                path: _path + ".contains",
+                expected: "(__type.o13 | __type.o14)",
+                value: input.contains
+            }, _errorFactory)); const _ao13 = (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.o11 | __type.o12 | __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.o11 | __type.o12 | __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.o11 | __type.o12 | __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.o11 | __type.o12 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
+                    value: value
+                }, _errorFactory));
+            }); const _ao14 = (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.o11 | __type.o12 | __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.o11 | __type.o12 | __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.o11 | __type.o12 | __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.o11 | __type.o12 | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o7 | __type.o8 | __type.o9 | bigint | readonly [Schema, ...Schema[]])",
+                    value: value
+                }, _errorFactory));
+            }); const _ao15 = (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.o11 | __type.o12 | __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.o11 | __type.o12 | __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.o11 | __type.o12 | __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.o11 | __type.o12 | __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 ("object" === typeof input.choice && null !== input.choice && false === Array.isArray(input.choice) && _au1(input.choice, _path + ".choice", false && _exceptionable))
+                    return _ao1(input, _path, true && _exceptionable);
+                else if (Array.isArray(input.choice) && (_ap2(input.choice, _path + ".choice", false && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                    method: "assert",
+                    path: _path + ".choice",
+                    expected: "ReadonlyArray<ValidateASN1.Schema> | Array<ValidateASN1.Schema>",
+                    value: input.choice
+                }, _errorFactory)))
+                    return _ao0(input, _path, true && _exceptionable);
+                else if (undefined !== input.sequenceOf)
+                    return _ao3(input, _path, true && _exceptionable);
+                else if (undefined !== input.optional)
+                    return _ao4(input, _path, true && _exceptionable);
+                else if ("context" === input.type)
+                    return _ao5(input, _path, true && _exceptionable);
+                else if ("oid" === input.type)
+                    return _ao6(input, _path, true && _exceptionable);
+                else if ("general" === input.kind)
+                    return _ao11(input, _path, true && _exceptionable);
+                else if ("utc" === input.kind)
+                    return _ao10(input, _path, true && _exceptionable);
+                else if ("utf8" === input.kind)
+                    return _ao9(input, _path, true && _exceptionable);
+                else if ("ia5" === input.kind)
+                    return _ao8(input, _path, true && _exceptionable);
+                else if ("printable" === input.kind)
+                    return _ao7(input, _path, true && _exceptionable);
+                else if ("struct" === input.type)
+                    return _ao12(input, _path, true && _exceptionable);
+                else
+                    return __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                        method: "assert",
+                        path: _path,
+                        expected: "(__type.o1 | __type | __type.o3 | __type.o4 | __type.o5 | __type.o6 | __type.o11 | __type.o10 | __type.o9 | __type.o8 | __type.o7 | __type.o12)",
+                        value: input
+                    }, _errorFactory);
+            })(); const _au1 = (input, _path, _exceptionable = true) => _ao15(input, _path, false && _exceptionable) || _ao2(input, _path, false && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                method: "assert",
+                path: _path,
+                expected: "(__type.o15 | __type.o2)",
+                value: input
+            }, _errorFactory); const _au2 = (input, _path, _exceptionable = true) => _ao14(input, _path, false && _exceptionable) || _ao13(input, _path, false && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                method: "assert",
+                path: _path,
+                expected: "(__type.o14 | __type.o13)",
+                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.o11 | __type.o12 | __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.o11 | __type.o12 | __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.o11 | __type.o12 | __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.o11 | __type.o12 | __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.o11 | __type.o12 | __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, _index22) => (null !== elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                method: "assert",
+                path: _path + "[" + (1 + _index22) + "]",
+                expected: "(__type | __type.o1 | __type.o10 | __type.o11 | __type.o12 | __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 + _index22) + "]",
+                expected: "(__type | __type.o1 | __type.o10 | __type.o11 | __type.o12 | __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 + _index22) + "]", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                method: "assert",
+                path: _path + "[" + (1 + _index22) + "]",
+                expected: "readonly [Schema, ...Schema[]]",
+                value: elem
+            }, _errorFactory)) || "object" === typeof elem && null !== elem && _au0(elem, _path + "[" + (1 + _index22) + "]", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+                method: "assert",
+                path: _path + "[" + (1 + _index22) + "]",
+                expected: "(__type | __type.o1 | __type.o10 | __type.o11 | __type.o12 | __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 + _index22) + "]",
+                expected: "(__type | __type.o1 | __type.o10 | __type.o11 | __type.o12 | __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.o11 | __type.o12 | __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.o11 | __type.o12 | __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.o11 | __type.o12 | __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.o11 | __type.o12 | __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.o11 | __type.o12 | __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
+                : Object.values(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, principals) {
+    if (input === undefined || input === null) {
+        return (input);
+    }
+    if (Array.isArray(input)) {
+        return (input.map(function (childInput) {
+            return (normalizeDecodedASN1(childInput, principals));
+        }));
+    }
+    if (input instanceof Date) {
+        return (input);
+    }
+    if (Buffer.isBuffer(input) || input instanceof ArrayBuffer) {
+        return (input);
+    }
+    if (isASN1ContextTag(input)) {
+        return (normalizeDecodedASN1(input.contains, principals));
+    }
+    if (isASN1String(input)) {
+        return (normalizeDecodedASN1(input.value, principals));
+    }
+    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, principals);
+            }
+        }
+        if (isReferenceSchema(input)) {
+            const url = input.contains.external.contains.url.value;
+            const mimeType = input.contains.external.contains.contentType.value;
+            const encryptionAlgoOID = input.contains.encryptionAlgorithm?.oid;
+            const digestInfo = input.contains.digest.contains;
+            let cachedValue = null;
+            result['$blob'] = async function (additionalPrincipals) {
+                /*
+                 * If we already have the cached value, return it
+                 */
+                if (cachedValue) {
+                    return (cachedValue);
+                }
+                /*
+                 * Fetch the remote data
+                 */
+                const result = await fetch(url);
+                if (!result.ok) {
+                    throw (new Error(`Failed to fetch remote data from ${url}: ${result.status} ${result.statusText}`));
+                }
+                const dataBlob = await result.blob();
+                let data = await dataBlob.arrayBuffer();
+                /*
+                 * Sometimes people like to encode the data
+                 * in a JSON base64 string, check to see if
+                 * that's the case -- hopefully this doesn't
+                 * conflict with any legitimate use case
+                 */
+                if (dataBlob.type === 'application/json') {
+                    try {
+                        const asJSON = JSON.parse(Buffer.from(data).toString('utf-8'));
+                        if (isPlainObject(asJSON)) {
+                            if (Object.keys(asJSON).length === 2) {
+                                if ('data' in asJSON && typeof asJSON.data === 'string' && 'mimeType' in asJSON && typeof asJSON.mimeType === 'string') {
+                                    data = bufferToArrayBuffer(Buffer.from(asJSON.data, 'base64'));
+                                }
+                            }
+                        }
+                    }
+                    catch {
+                        /* Ignored */
+                    }
+                }
+                /*
+                 * Decrypt the data, if encrypted
+                 */
+                if (encryptionAlgoOID) {
+                    switch (encryptionAlgoOID) {
+                        case '1.3.6.1.4.1.62675.2':
+                        case 'KeetaEncryptedContainerV1': {
+                            const container = EncryptedContainer.fromEncryptedBuffer(data, [
+                                ...principals,
+                                ...(additionalPrincipals ?? [])
+                            ]);
+                            data = await container.getPlaintext();
+                            break;
+                        }
+                        default:
+                            throw (new Error(`Unsupported encryption algorithm OID: ${encryptionAlgoOID}`));
+                    }
+                }
+                /*
+                 * Compute and verify the hash (of the plain text)
+                 */
+                if (!Buffer.isBuffer(digestInfo.digest)) {
+                    throw (new TypeError('Digest value is not a buffer'));
+                }
+                const validHash = await checkHashWithOID(data, {
+                    digest: digestInfo.digest,
+                    digestAlgorithm: digestInfo.digestAlgorithm
+                });
+                if (validHash !== true) {
+                    throw (validHash);
+                }
+                const blob = new Blob([data], { type: mimeType });
+                cachedValue = blob;
+                return (blob);
+            };
+        }
+        return (result);
+    }
+    if (isASN1Set(input)) {
+        return ({
+            name: normalizeDecodedASN1(input.name, principals),
+            value: normalizeDecodedASN1(input.value, principals)
+        });
+    }
+    if (isPlainObject(input)) {
+        const result = {};
+        for (const [key, value] of Object.entries(input)) {
+            result[key] = normalizeDecodedASN1(value, principals);
+        }
+        return (result);
+    }
+    return (input);
+}
 export { ASN1toJS, JStoASN1, BufferStorageASN1, ValidateASN1 };
 //# sourceMappingURL=asn1.js.map